tools/intel_reg_dumper.c

   1 /*
   2  * Copyright © 2006,2009 Intel Corporation
   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 (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *
  26  */
  27
  28 #define _GNU_SOURCE
  29 #include <ctype.h>
  30 #include <stdbool.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <err.h>
  35 #include <unistd.h>
  36 #include "intel_gpu_tools.h"
  37
  38 static uint32_t devid = 0;
  39
  40 #define DEBUGSTRING(func) static void func(char *result, int len, int reg, uint32_t val)
  41
  42 DEBUGSTRING(i830_16bit_func)
  43 {
  44         snprintf(result, len, "0x%04x", (uint16_t) val);
  45 }
  46
  47 DEBUGSTRING(i830_debug_dcc)
  48 {
  49         const char *addressing = NULL;
  50
  51         if (!IS_MOBILE(devid))
  52                 return;
  53
  54         if (IS_965(devid)) {
  55                 if (val & (1 << 1))
  56                         addressing = "dual channel interleaved";
  57                 else
  58                         addressing = "single or dual channel asymmetric";
  59         } else {
  60                 switch (val & 3) {
  61                 case 0:
  62                         addressing = "single channel";
  63                         break;
  64                 case 1:
  65                         addressing = "dual channel asymmetric";
  66                         break;
  67                 case 2:
  68                         addressing = "dual channel interleaved";
  69                         break;
  70                 case 3:
  71                         addressing = "unknown channel layout";
  72                         break;
  73                 }
  74         }
  75
  76         snprintf(result, len, "%s, XOR randomization: %sabled, XOR bit: %d",
  77                  addressing,
  78                  (val & (1 << 10)) ? "dis" : "en",
  79                  (val & (1 << 9)) ? 17 : 11);
  80 }
  81
  82 DEBUGSTRING(i830_debug_chdecmisc)
  83 {
  84         const char *enhmodesel = NULL;
  85
  86         switch ((val >> 5) & 3) {
  87         case 1:
  88                 enhmodesel = "XOR bank/rank";
  89                 break;
  90         case 2:
  91                 enhmodesel = "swap bank";
  92                 break;
  93         case 3:
  94                 enhmodesel = "XOR bank";
  95                 break;
  96         case 0:
  97                 enhmodesel = "none";
  98                 break;
  99         }
 100
 101         snprintf(result, len,
 102                  "%s, ch2 enh %sabled, ch1 enh %sabled, "
 103                  "ch0 enh %sabled, "
 104                  "flex %sabled, ep %spresent", enhmodesel,
 105                  (val & (1 << 4)) ? "en" : "dis",
 106                  (val & (1 << 3)) ? "en" : "dis",
 107                  (val & (1 << 2)) ? "en" : "dis",
 108                  (val & (1 << 1)) ? "en" : "dis",
 109                  (val & (1 << 0)) ? "" : "not ");
 110 }
 111
 112 DEBUGSTRING(i830_debug_xyminus1)
 113 {
 114         snprintf(result, len, "%d, %d", (val & 0xffff) + 1,
 115                  ((val & 0xffff0000) >> 16) + 1);
 116 }
 117
 118 DEBUGSTRING(i830_debug_yxminus1)
 119 {
 120         snprintf(result, len, "%d, %d", ((val & 0xffff0000) >> 16) + 1,
 121                  (val & 0xffff) + 1);
 122 }
 123
 124 DEBUGSTRING(i830_debug_xy)
 125 {
 126         snprintf(result, len, "%d, %d", (val & 0xffff), ((val & 0xffff0000) >> 16));
 127 }
 128
 129 DEBUGSTRING(i830_debug_dspstride)
 130 {
 131         snprintf(result, len, "%d bytes", val);
 132 }
 133
 134 DEBUGSTRING(i830_debug_dspcntr)
 135 {
 136         const char *enabled = val & DISPLAY_PLANE_ENABLE ? "enabled" : "disabled";
 137         char plane = val & DISPPLANE_SEL_PIPE_B ? 'B' : 'A';
 138         if (HAS_PCH_SPLIT(devid))
 139                 snprintf(result, len, "%s", enabled);
 140         else
 141                 snprintf(result, len, "%s, pipe %c", enabled, plane);
 142 }
 143
 144 DEBUGSTRING(i830_debug_pipeconf)
 145 {
 146         const char *enabled = val & PIPEACONF_ENABLE ? "enabled" : "disabled";
 147         const char *bit30, *interlace;
 148
 149         if (IS_965(devid))
 150                 bit30 = val & I965_PIPECONF_ACTIVE ? "active" : "inactive";
 151         else
 152                 bit30 =
 153                     val & PIPEACONF_DOUBLE_WIDE ? "double-wide" : "single-wide";
 154
 155         if (HAS_PCH_SPLIT(devid)) {
 156                 const char *bpc, *rotation;
 157
 158                 switch ((val >> 21) & 7) {
 159                 case 0:
 160                         interlace = "pf-pd";
 161                         break;
 162                 case 1:
 163                         interlace = "pf-id";
 164                         break;
 165                 case 3:
 166                         interlace = "if-id";
 167                         break;
 168                 case 4:
 169                         interlace = "if-id-dbl";
 170                         break;
 171                 case 5:
 172                         interlace = "pf-id-dbl";
 173                         break;
 174                 default:
 175                         interlace = "rsvd";
 176                         break;
 177                 }
 178
 179                 switch ((val >> 14) & 3) {
 180                 case 0:
 181                         rotation = "rotate 0";
 182                         break;
 183                 case 1:
 184                         rotation = "rotate 90";
 185                         break;
 186                 case 2:
 187                         rotation = "rotate 180";
 188                         break;
 189                 case 3:
 190                         rotation = "rotate 270";
 191                         break;
 192                 }
 193
 194                 switch (val & (7 << 5)) {
 195                 case PIPECONF_8BPP:
 196                         bpc = "8bpc";
 197                         break;
 198                 case PIPECONF_10BPP:
 199                         bpc = "10bpc";
 200                         break;
 201                 case PIPECONF_6BPP:
 202                         bpc = "6bpc";
 203                         break;
 204                 case PIPECONF_12BPP:
 205                         bpc = "12bpc";
 206                         break;
 207                 default:
 208                         bpc = "invalid bpc";
 209                         break;
 210                 }
 211                 snprintf(result, len, "%s, %s, %s, %s, %s", enabled, bit30,
 212                          interlace, rotation, bpc);
 213         } else if (IS_GEN4(devid)) {
 214                 switch ((val >> 21) & 7) {
 215                 case 0:
 216                 case 1:
 217                 case 2:
 218                 case 3:
 219                         interlace = "progressive";
 220                         break;
 221                 case 4:
 222                         interlace = "interlaced embedded";
 223                         break;
 224                 case 5:
 225                         interlace = "interlaced";
 226                         break;
 227                 case 6:
 228                         interlace = "interlaced sdvo";
 229                         break;
 230                 case 7:
 231                         interlace = "interlaced legacy";
 232                         break;
 233                 }
 234                 snprintf(result, len, "%s, %s, %s", enabled, bit30, interlace);
 235         } else
 236                 snprintf(result, len, "%s, %s", enabled, bit30);
 237 }
 238
 239 DEBUGSTRING(i830_debug_pipestat)
 240 {
 241         const char *_FIFO_UNDERRUN = val & FIFO_UNDERRUN ? " FIFO_UNDERRUN" : "";
 242         const char *_CRC_ERROR_ENABLE =
 243             val & CRC_ERROR_ENABLE ? " CRC_ERROR_ENABLE" : "";
 244         const char *_CRC_DONE_ENABLE =
 245             val & CRC_DONE_ENABLE ? " CRC_DONE_ENABLE" : "";
 246         const char *_GMBUS_EVENT_ENABLE =
 247             val & GMBUS_EVENT_ENABLE ? " GMBUS_EVENT_ENABLE" : "";
 248         const char *_VSYNC_INT_ENABLE =
 249             val & VSYNC_INT_ENABLE ? " VSYNC_INT_ENABLE" : "";
 250         const char *_DLINE_COMPARE_ENABLE =
 251             val & DLINE_COMPARE_ENABLE ? " DLINE_COMPARE_ENABLE" : "";
 252         const char *_DPST_EVENT_ENABLE =
 253             val & DPST_EVENT_ENABLE ? " DPST_EVENT_ENABLE" : "";
 254         const char *_LBLC_EVENT_ENABLE =
 255             val & LBLC_EVENT_ENABLE ? " LBLC_EVENT_ENABLE" : "";
 256         const char *_OFIELD_INT_ENABLE =
 257             val & OFIELD_INT_ENABLE ? " OFIELD_INT_ENABLE" : "";
 258         const char *_EFIELD_INT_ENABLE =
 259             val & EFIELD_INT_ENABLE ? " EFIELD_INT_ENABLE" : "";
 260         const char *_SVBLANK_INT_ENABLE =
 261             val & SVBLANK_INT_ENABLE ? " SVBLANK_INT_ENABLE" : "";
 262         const char *_VBLANK_INT_ENABLE =
 263             val & VBLANK_INT_ENABLE ? " VBLANK_INT_ENABLE" : "";
 264         const char *_OREG_UPDATE_ENABLE =
 265             val & OREG_UPDATE_ENABLE ? " OREG_UPDATE_ENABLE" : "";
 266         const char *_CRC_ERROR_INT_STATUS =
 267             val & CRC_ERROR_INT_STATUS ? " CRC_ERROR_INT_STATUS" : "";
 268         const char *_CRC_DONE_INT_STATUS =
 269             val & CRC_DONE_INT_STATUS ? " CRC_DONE_INT_STATUS" : "";
 270         const char *_GMBUS_INT_STATUS =
 271             val & GMBUS_INT_STATUS ? " GMBUS_INT_STATUS" : "";
 272         const char *_VSYNC_INT_STATUS =
 273             val & VSYNC_INT_STATUS ? " VSYNC_INT_STATUS" : "";
 274         const char *_DLINE_COMPARE_STATUS =
 275             val & DLINE_COMPARE_STATUS ? " DLINE_COMPARE_STATUS" : "";
 276         const char *_DPST_EVENT_STATUS =
 277             val & DPST_EVENT_STATUS ? " DPST_EVENT_STATUS" : "";
 278         const char *_LBLC_EVENT_STATUS =
 279             val & LBLC_EVENT_STATUS ? " LBLC_EVENT_STATUS" : "";
 280         const char *_OFIELD_INT_STATUS =
 281             val & OFIELD_INT_STATUS ? " OFIELD_INT_STATUS" : "";
 282         const char *_EFIELD_INT_STATUS =
 283             val & EFIELD_INT_STATUS ? " EFIELD_INT_STATUS" : "";
 284         const char *_SVBLANK_INT_STATUS =
 285             val & SVBLANK_INT_STATUS ? " SVBLANK_INT_STATUS" : "";
 286         const char *_VBLANK_INT_STATUS =
 287             val & VBLANK_INT_STATUS ? " VBLANK_INT_STATUS" : "";
 288         const char *_OREG_UPDATE_STATUS =
 289             val & OREG_UPDATE_STATUS ? " OREG_UPDATE_STATUS" : "";
 290         snprintf(result, len,
 291                  "status:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
 292                  _FIFO_UNDERRUN,
 293                  _CRC_ERROR_ENABLE,
 294                  _CRC_DONE_ENABLE,
 295                  _GMBUS_EVENT_ENABLE,
 296                  _VSYNC_INT_ENABLE,
 297                  _DLINE_COMPARE_ENABLE,
 298                  _DPST_EVENT_ENABLE,
 299                  _LBLC_EVENT_ENABLE,
 300                  _OFIELD_INT_ENABLE,
 301                  _EFIELD_INT_ENABLE,
 302                  _SVBLANK_INT_ENABLE,
 303                  _VBLANK_INT_ENABLE,
 304                  _OREG_UPDATE_ENABLE,
 305                  _CRC_ERROR_INT_STATUS,
 306                  _CRC_DONE_INT_STATUS,
 307                  _GMBUS_INT_STATUS,
 308                  _VSYNC_INT_STATUS,
 309                  _DLINE_COMPARE_STATUS,
 310                  _DPST_EVENT_STATUS,
 311                  _LBLC_EVENT_STATUS,
 312                  _OFIELD_INT_STATUS,
 313                  _EFIELD_INT_STATUS,
 314                  _SVBLANK_INT_STATUS,
 315                  _VBLANK_INT_STATUS,
 316                  _OREG_UPDATE_STATUS);
 317 }
 318
 319 DEBUGSTRING(ivb_debug_port)
 320 {
 321         const char *drrs = NULL;
 322         switch (val & (2 << 30)) {
 323                 case PORT_DBG_DRRS_HW_STATE_OFF:
 324                         drrs = "off";
 325                         break;
 326                 case PORT_DBG_DRRS_HW_STATE_LOW:
 327                         drrs = "low";
 328                         break;
 329                 case PORT_DBG_DRRS_HW_STATE_HIGH:
 330                         drrs = "high";
 331                         break;
 332         }
 333         snprintf(result, len, "HW DRRS %s",
 334                         drrs);
 335 }
 336
 337 DEBUGSTRING(i830_debug_hvtotal)
 338 {
 339         snprintf(result, len, "%d active, %d total",
 340                  (val & 0xffff) + 1,
 341                  ((val & 0xffff0000) >> 16) + 1);
 342 }
 343
 344 DEBUGSTRING(i830_debug_hvsyncblank)
 345 {
 346         snprintf(result, len, "%d start, %d end",
 347                  (val & 0xffff) + 1,
 348                  ((val & 0xffff0000) >> 16) + 1);
 349 }
 350
 351 DEBUGSTRING(i830_debug_vgacntrl)
 352 {
 353         snprintf(result, len, "%s",
 354                  val & VGA_DISP_DISABLE ? "disabled" : "enabled");
 355 }
 356
 357 DEBUGSTRING(i830_debug_fp)
 358 {
 359         if (IS_IGD(devid)) {
 360                 snprintf(result, len, "n = %d, m1 = %d, m2 = %d",
 361                          ffs((val & FP_N_IGD_DIV_MASK) >>
 362                              FP_N_DIV_SHIFT) - 1,
 363                          ((val & FP_M1_DIV_MASK) >> FP_M1_DIV_SHIFT),
 364                          ((val & FP_M2_IGD_DIV_MASK) >>
 365                           FP_M2_DIV_SHIFT));
 366         }
 367         snprintf(result, len, "n = %d, m1 = %d, m2 = %d",
 368                  ((val & FP_N_DIV_MASK) >> FP_N_DIV_SHIFT),
 369                  ((val & FP_M1_DIV_MASK) >> FP_M1_DIV_SHIFT),
 370                  ((val & FP_M2_DIV_MASK) >> FP_M2_DIV_SHIFT));
 371 }
 372
 373 DEBUGSTRING(i830_debug_vga_pd)
 374 {
 375         int vga0_p1, vga0_p2, vga1_p1, vga1_p2;
 376
 377         /* XXX: i9xx version */
 378
 379         if (val & VGA0_PD_P1_DIV_2)
 380                 vga0_p1 = 2;
 381         else
 382                 vga0_p1 = ((val & VGA0_PD_P1_MASK) >> VGA0_PD_P1_SHIFT) + 2;
 383         vga0_p2 = (val & VGA0_PD_P2_DIV_4) ? 4 : 2;
 384
 385         if (val & VGA1_PD_P1_DIV_2)
 386                 vga1_p1 = 2;
 387         else
 388                 vga1_p1 = ((val & VGA1_PD_P1_MASK) >> VGA1_PD_P1_SHIFT) + 2;
 389         vga1_p2 = (val & VGA1_PD_P2_DIV_4) ? 4 : 2;
 390
 391         snprintf(result, len, "vga0 p1 = %d, p2 = %d, vga1 p1 = %d, p2 = %d",
 392                          vga0_p1, vga0_p2, vga1_p1, vga1_p2);
 393 }
 394
 395 DEBUGSTRING(i830_debug_pp_status)
 396 {
 397         const char *status = val & PP_ON ? "on" : "off";
 398         const char *ready = val & PP_READY ? "ready" : "not ready";
 399         const char *seq = "unknown";
 400
 401         switch (val & PP_SEQUENCE_MASK) {
 402         case PP_SEQUENCE_NONE:
 403                 seq = "idle";
 404                 break;
 405         case PP_SEQUENCE_ON:
 406                 seq = "on";
 407                 break;
 408         case PP_SEQUENCE_OFF:
 409                 seq = "off";
 410                 break;
 411         }
 412
 413         snprintf(result, len, "%s, %s, sequencing %s", status, ready, seq);
 414 }
 415
 416 DEBUGSTRING(i830_debug_pp_control)
 417 {
 418         snprintf(result, len, "power target: %s",
 419                          val & POWER_TARGET_ON ? "on" : "off");
 420 }
 421
 422 DEBUGSTRING(i830_debug_dpll)
 423 {
 424         const char *enabled = val & DPLL_VCO_ENABLE ? "enabled" : "disabled";
 425         const char *dvomode = val & DPLL_DVO_HIGH_SPEED ? "dvo" : "non-dvo";
 426         const char *vgamode = val & DPLL_VGA_MODE_DIS ? "" : ", VGA";
 427         const char *mode = "unknown";
 428         const char *clock = "unknown";
 429         const char *fpextra = val & DISPLAY_RATE_SELECT_FPA1 ? ", using FPx1!" : "";
 430         char sdvoextra[20];
 431         int p1, p2 = 0;
 432
 433         if (IS_GEN2(devid)) {
 434                 char is_lvds = (INREG(LVDS) & LVDS_PORT_EN) && (reg == DPLL_B);
 435
 436                 if (is_lvds) {
 437                         mode = "LVDS";
 438                         p1 = ffs((val & DPLL_FPA01_P1_POST_DIV_MASK_I830_LVDS)
 439                                  >> DPLL_FPA01_P1_POST_DIV_SHIFT);
 440                         if ((INREG(LVDS) & LVDS_CLKB_POWER_MASK) ==
 441                             LVDS_CLKB_POWER_UP)
 442                                 p2 = 7;
 443                         else
 444                                 p2 = 14;
 445
 446                 } else {
 447                         mode = "DAC/serial";
 448                         if (val & PLL_P1_DIVIDE_BY_TWO) {
 449                                 p1 = 2;
 450                         } else {
 451                                 /* Map the number in the field to (3, 33) */
 452                                 p1 = ((val & DPLL_FPA01_P1_POST_DIV_MASK_I830)
 453                                       >> DPLL_FPA01_P1_POST_DIV_SHIFT) + 2;
 454                         }
 455                         if (val & PLL_P2_DIVIDE_BY_4)
 456                                 p2 = 4;
 457                         else
 458                                 p2 = 2;
 459                 }
 460         } else {
 461                 if (IS_IGD(devid)) {
 462                         p1 = ffs((val & DPLL_FPA01_P1_POST_DIV_MASK_IGD) >>
 463                                  DPLL_FPA01_P1_POST_DIV_SHIFT_IGD);
 464                 } else {
 465                         p1 = ffs((val & DPLL_FPA01_P1_POST_DIV_MASK) >>
 466                                  DPLL_FPA01_P1_POST_DIV_SHIFT);
 467                 }
 468                 switch (val & DPLL_MODE_MASK) {
 469                 case DPLLB_MODE_DAC_SERIAL:
 470                         mode = "DAC/serial";
 471                         p2 = val & DPLL_DAC_SERIAL_P2_CLOCK_DIV_5 ? 5 : 10;
 472                         break;
 473                 case DPLLB_MODE_LVDS:
 474                         mode = "LVDS";
 475                         p2 = val & DPLLB_LVDS_P2_CLOCK_DIV_7 ? 7 : 14;
 476                         break;
 477                 }
 478         }
 479
 480         switch (val & PLL_REF_INPUT_MASK) {
 481         case PLL_REF_INPUT_DREFCLK:
 482                 clock = "default";
 483                 break;
 484         case PLL_REF_INPUT_TVCLKINA:
 485                 clock = "TV A";
 486                 break;
 487         case PLL_REF_INPUT_TVCLKINBC:
 488                 clock = "TV B/C";
 489                 break;
 490         case PLLB_REF_INPUT_SPREADSPECTRUMIN:
 491                 if (reg == DPLL_B)
 492                         clock = "spread spectrum";
 493                 break;
 494         }
 495
 496         if (IS_945(devid)) {
 497                 sprintf(sdvoextra, ", SDVO mult %d",
 498                         (int)((val & SDVO_MULTIPLIER_MASK) >>
 499                               SDVO_MULTIPLIER_SHIFT_HIRES) + 1);
 500         } else {
 501                 sdvoextra[0] = '\0';
 502         }
 503
 504         snprintf(result, len, "%s, %s%s, %s clock, %s mode, p1 = %d, "
 505                          "p2 = %d%s%s",
 506                          enabled, dvomode, vgamode, clock, mode, p1, p2,
 507                          fpextra, sdvoextra);
 508 }
 509
 510 DEBUGSTRING(i830_debug_dpll_test)
 511 {
 512         const char *dpllandiv = val & DPLLA_TEST_N_BYPASS ? ", DPLLA N bypassed" : "";
 513         const char *dpllamdiv = val & DPLLA_TEST_M_BYPASS ? ", DPLLA M bypassed" : "";
 514         const char *dpllainput = val & DPLLA_INPUT_BUFFER_ENABLE ?
 515             "" : ", DPLLA input buffer disabled";
 516         const char *dpllbndiv = val & DPLLB_TEST_N_BYPASS ? ", DPLLB N bypassed" : "";
 517         const char *dpllbmdiv = val & DPLLB_TEST_M_BYPASS ? ", DPLLB M bypassed" : "";
 518         const char *dpllbinput = val & DPLLB_INPUT_BUFFER_ENABLE ?
 519             "" : ", DPLLB input buffer disabled";
 520
 521         snprintf(result, len, "%s%s%s%s%s%s",
 522                          dpllandiv, dpllamdiv, dpllainput,
 523                          dpllbndiv, dpllbmdiv, dpllbinput);
 524 }
 525
 526 DEBUGSTRING(i830_debug_adpa)
 527 {
 528         char disp_pipe = (val & ADPA_PIPE_B_SELECT) ? 'B' : 'A';
 529         const char *enable = (val & ADPA_DAC_ENABLE) ? "enabled" : "disabled";
 530         char hsync = (val & ADPA_HSYNC_ACTIVE_HIGH) ? '+' : '-';
 531         char vsync = (val & ADPA_VSYNC_ACTIVE_HIGH) ? '+' : '-';
 532
 533         if (HAS_CPT)
 534                 disp_pipe = val & (1<<29) ? 'B' : 'A';
 535
 536         if (HAS_PCH_SPLIT(devid))
 537                 snprintf(result, len, "%s, transcoder %c, %chsync, %cvsync",
 538                                  enable, disp_pipe, hsync, vsync);
 539         else
 540                 snprintf(result, len, "%s, pipe %c, %chsync, %cvsync",
 541                                  enable, disp_pipe, hsync, vsync);
 542 }
 543
 544 DEBUGSTRING(i830_debug_lvds)
 545 {
 546         char disp_pipe = val & LVDS_PIPEB_SELECT ? 'B' : 'A';
 547         const char *enable = val & LVDS_PORT_EN ? "enabled" : "disabled";
 548         int depth;
 549         const char *channels;
 550
 551         if ((val & LVDS_A3_POWER_MASK) == LVDS_A3_POWER_UP)
 552                 depth = 24;
 553         else
 554                 depth = 18;
 555         if ((val & LVDS_B0B3_POWER_MASK) == LVDS_B0B3_POWER_UP)
 556                 channels = "2 channels";
 557         else
 558                 channels = "1 channel";
 559
 560         if (HAS_CPT)
 561                 disp_pipe = val & (1<<29) ? 'B' : 'A';
 562
 563         snprintf(result, len, "%s, pipe %c, %d bit, %s",
 564                          enable, disp_pipe, depth, channels);
 565 }
 566
 567 DEBUGSTRING(i830_debug_dvo)
 568 {
 569         const char *enable = val & DVO_ENABLE ? "enabled" : "disabled";
 570         char disp_pipe = val & DVO_PIPE_B_SELECT ? 'B' : 'A';
 571         const char *stall;
 572         char hsync = val & DVO_HSYNC_ACTIVE_HIGH ? '+' : '-';
 573         char vsync = val & DVO_VSYNC_ACTIVE_HIGH ? '+' : '-';
 574
 575         switch (val & DVO_PIPE_STALL_MASK) {
 576         case DVO_PIPE_STALL_UNUSED:
 577                 stall = "no stall";
 578                 break;
 579         case DVO_PIPE_STALL:
 580                 stall = "stall";
 581                 break;
 582         case DVO_PIPE_STALL_TV:
 583                 stall = "TV stall";
 584                 break;
 585         default:
 586                 stall = "unknown stall";
 587                 break;
 588         }
 589
 590         snprintf(result, len, "%s, pipe %c, %s, %chsync, %cvsync",
 591                          enable, disp_pipe, stall, hsync, vsync);
 592 }
 593
 594 DEBUGSTRING(i830_debug_sdvo)
 595 {
 596         const char *enable = val & SDVO_ENABLE ? "enabled" : "disabled";
 597         char disp_pipe = val & SDVO_PIPE_B_SELECT ? 'B' : 'A';
 598         const char *stall = val & SDVO_STALL_SELECT ? "enabled" : "disabled";
 599         const char *detected = val & SDVO_DETECTED ? "" : "not ";
 600         const char *gang = val & SDVOC_GANG_MODE ? ", gang mode" : "";
 601         char sdvoextra[20];
 602
 603         if (IS_915(devid)) {
 604                 sprintf(sdvoextra, ", SDVO mult %d",
 605                         (int)((val & SDVO_PORT_MULTIPLY_MASK) >>
 606                               SDVO_PORT_MULTIPLY_SHIFT) + 1);
 607         } else {
 608                 sdvoextra[0] = '\0';
 609         }
 610
 611         snprintf(result, len, "%s, pipe %c, stall %s, %sdetected%s%s",
 612                          enable, disp_pipe, stall, detected, sdvoextra, gang);
 613 }
 614
 615 DEBUGSTRING(i830_debug_dspclk_gate_d)
 616 {
 617         const char *DPUNIT_B = val & DPUNIT_B_CLOCK_GATE_DISABLE ? " DPUNIT_B" : "";
 618         const char *VSUNIT = val & VSUNIT_CLOCK_GATE_DISABLE ? " VSUNIT" : "";
 619         const char *VRHUNIT = val & VRHUNIT_CLOCK_GATE_DISABLE ? " VRHUNIT" : "";
 620         const char *VRDUNIT = val & VRDUNIT_CLOCK_GATE_DISABLE ? " VRDUNIT" : "";
 621         const char *AUDUNIT = val & AUDUNIT_CLOCK_GATE_DISABLE ? " AUDUNIT" : "";
 622         const char *DPUNIT_A = val & DPUNIT_A_CLOCK_GATE_DISABLE ? " DPUNIT_A" : "";
 623         const char *DPCUNIT = val & DPCUNIT_CLOCK_GATE_DISABLE ? " DPCUNIT" : "";
 624         const char *TVRUNIT = val & TVRUNIT_CLOCK_GATE_DISABLE ? " TVRUNIT" : "";
 625         const char *TVCUNIT = val & TVCUNIT_CLOCK_GATE_DISABLE ? " TVCUNIT" : "";
 626         const char *TVFUNIT = val & TVFUNIT_CLOCK_GATE_DISABLE ? " TVFUNIT" : "";
 627         const char *TVEUNIT = val & TVEUNIT_CLOCK_GATE_DISABLE ? " TVEUNIT" : "";
 628         const char *DVSUNIT = val & DVSUNIT_CLOCK_GATE_DISABLE ? " DVSUNIT" : "";
 629         const char *DSSUNIT = val & DSSUNIT_CLOCK_GATE_DISABLE ? " DSSUNIT" : "";
 630         const char *DDBUNIT = val & DDBUNIT_CLOCK_GATE_DISABLE ? " DDBUNIT" : "";
 631         const char *DPRUNIT = val & DPRUNIT_CLOCK_GATE_DISABLE ? " DPRUNIT" : "";
 632         const char *DPFUNIT = val & DPFUNIT_CLOCK_GATE_DISABLE ? " DPFUNIT" : "";
 633         const char *DPBMUNIT = val & DPBMUNIT_CLOCK_GATE_DISABLE ? " DPBMUNIT" : "";
 634         const char *DPLSUNIT = val & DPLSUNIT_CLOCK_GATE_DISABLE ? " DPLSUNIT" : "";
 635         const char *DPLUNIT = val & DPLUNIT_CLOCK_GATE_DISABLE ? " DPLUNIT" : "";
 636         const char *DPOUNIT = val & DPOUNIT_CLOCK_GATE_DISABLE ? " DPOUNIT" : "";
 637         const char *DPBUNIT = val & DPBUNIT_CLOCK_GATE_DISABLE ? " DPBUNIT" : "";
 638         const char *DCUNIT = val & DCUNIT_CLOCK_GATE_DISABLE ? " DCUNIT" : "";
 639         const char *DPUNIT = val & DPUNIT_CLOCK_GATE_DISABLE ? " DPUNIT" : "";
 640         const char *VRUNIT = val & VRUNIT_CLOCK_GATE_DISABLE ? " VRUNIT" : "";
 641         const char *OVHUNIT = val & OVHUNIT_CLOCK_GATE_DISABLE ? " OVHUNIT" : "";
 642         const char *DPIOUNIT = val & DPIOUNIT_CLOCK_GATE_DISABLE ? " DPIOUNIT" : "";
 643         const char *OVFUNIT = val & OVFUNIT_CLOCK_GATE_DISABLE ? " OVFUNIT" : "";
 644         const char *OVBUNIT = val & OVBUNIT_CLOCK_GATE_DISABLE ? " OVBUNIT" : "";
 645         const char *OVRUNIT = val & OVRUNIT_CLOCK_GATE_DISABLE ? " OVRUNIT" : "";
 646         const char *OVCUNIT = val & OVCUNIT_CLOCK_GATE_DISABLE ? " OVCUNIT" : "";
 647         const char *OVUUNIT = val & OVUUNIT_CLOCK_GATE_DISABLE ? " OVUUNIT" : "";
 648         const char *OVLUNIT = val & OVLUNIT_CLOCK_GATE_DISABLE ? " OVLUNIT" : "";
 649
 650         snprintf(result, len,
 651                  "clock gates disabled:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
 652                  DPUNIT_B, VSUNIT, VRHUNIT, VRDUNIT, AUDUNIT, DPUNIT_A, DPCUNIT,
 653                  TVRUNIT, TVCUNIT, TVFUNIT, TVEUNIT, DVSUNIT, DSSUNIT, DDBUNIT,
 654                  DPRUNIT, DPFUNIT, DPBMUNIT, DPLSUNIT, DPLUNIT, DPOUNIT, DPBUNIT,
 655                  DCUNIT, DPUNIT, VRUNIT, OVHUNIT, DPIOUNIT, OVFUNIT, OVBUNIT,
 656                  OVRUNIT, OVCUNIT, OVUUNIT, OVLUNIT);
 657 }
 658
 659 DEBUGSTRING(i810_debug_915_fence)
 660 {
 661         char format = (val & 1 << 12) ? 'Y' : 'X';
 662         int pitch = 128 << ((val & 0x70) >> 4);
 663         unsigned int offset = val & 0x0ff00000;
 664         int size = (1024 * 1024) << ((val & 0x700) >> 8);
 665
 666         if (IS_965(devid) || (IS_915(devid) && reg >= FENCE_NEW))
 667                 return;
 668
 669         if (format == 'X')
 670                 pitch *= 4;
 671         if (val & 1) {
 672                 snprintf(result, len, "enabled, %c tiled, %4d pitch, 0x%08x - 0x%08x (%dkb)",
 673                          format, pitch, offset, offset + size,
 674                          size / 1024);
 675         } else {
 676                 snprintf(result, len, "disabled");
 677         }
 678 }
 679
 680 DEBUGSTRING(i810_debug_965_fence_start)
 681 {
 682         const char *enable = (val & FENCE_VALID) ? " enabled" : "disabled";
 683         char format = (val & I965_FENCE_Y_MAJOR) ? 'Y' : 'X';
 684         int pitch = ((val & 0xffc) >> 2) * 128 + 128;
 685         unsigned int offset = val & 0xfffff000;
 686
 687         if (!IS_965(devid))
 688                 return;
 689
 690         snprintf(result, len, "%s, %c tile walk, %4d pitch, 0x%08x start",
 691                  enable, format, pitch, offset);
 692 }
 693
 694 DEBUGSTRING(i810_debug_965_fence_end)
 695 {
 696         unsigned int end = val & 0xfffff000;
 697
 698         if (!IS_965(devid))
 699                 return;
 700
 701         snprintf(result, len, "                                   0x%08x end", end);
 702 }
 703
 704 #define DEFINEREG(reg) \
 705         { reg, #reg, NULL, 0 }
 706 #define DEFINEREG_16BIT(reg) \
 707         { reg, #reg, i830_16bit_func, 0 }
 708 #define DEFINEREG2(reg, func) \
 709         { reg, #reg, func, 0 }
 710
 711 struct reg_debug {
 712         int reg;
 713         const char *name;
 714         void (*debug_output) (char *result, int len, int reg, uint32_t val);
 715         uint32_t val;
 716 };
 717
 718 static struct reg_debug intel_debug_regs[] = {
 719         DEFINEREG2(DCC, i830_debug_dcc),
 720         DEFINEREG2(CHDECMISC, i830_debug_chdecmisc),
 721         DEFINEREG_16BIT(C0DRB0),
 722         DEFINEREG_16BIT(C0DRB1),
 723         DEFINEREG_16BIT(C0DRB2),
 724         DEFINEREG_16BIT(C0DRB3),
 725         DEFINEREG_16BIT(C1DRB0),
 726         DEFINEREG_16BIT(C1DRB1),
 727         DEFINEREG_16BIT(C1DRB2),
 728         DEFINEREG_16BIT(C1DRB3),
 729         DEFINEREG_16BIT(C0DRA01),
 730         DEFINEREG_16BIT(C0DRA23),
 731         DEFINEREG_16BIT(C1DRA01),
 732         DEFINEREG_16BIT(C1DRA23),
 733
 734         DEFINEREG(PGETBL_CTL),
 735
 736         DEFINEREG2(VCLK_DIVISOR_VGA0, i830_debug_fp),
 737         DEFINEREG2(VCLK_DIVISOR_VGA1, i830_debug_fp),
 738         DEFINEREG2(VCLK_POST_DIV, i830_debug_vga_pd),
 739         DEFINEREG2(DPLL_TEST, i830_debug_dpll_test),
 740         DEFINEREG(CACHE_MODE_0),
 741         DEFINEREG(D_STATE),
 742         DEFINEREG2(DSPCLK_GATE_D, i830_debug_dspclk_gate_d),
 743         DEFINEREG(RENCLK_GATE_D1),
 744         DEFINEREG(RENCLK_GATE_D2),
 745 /*  DEFINEREG(RAMCLK_GATE_D),   CRL only */
 746         DEFINEREG2(SDVOB, i830_debug_sdvo),
 747         DEFINEREG2(SDVOC, i830_debug_sdvo),
 748 /*    DEFINEREG(UDIB_SVB_SHB_CODES), CRL only */
 749 /*    DEFINEREG(UDIB_SHA_BLANK_CODES), CRL only */
 750         DEFINEREG(SDVOUDI),
 751         DEFINEREG(DSPARB),
 752         DEFINEREG(DSPFW1),
 753         DEFINEREG(DSPFW2),
 754         DEFINEREG(DSPFW3),
 755
 756         DEFINEREG2(ADPA, i830_debug_adpa),
 757         DEFINEREG2(LVDS, i830_debug_lvds),
 758         DEFINEREG2(DVOA, i830_debug_dvo),
 759         DEFINEREG2(DVOB, i830_debug_dvo),
 760         DEFINEREG2(DVOC, i830_debug_dvo),
 761         DEFINEREG(DVOA_SRCDIM),
 762         DEFINEREG(DVOB_SRCDIM),
 763         DEFINEREG(DVOC_SRCDIM),
 764
 765         DEFINEREG(BLC_PWM_CTL),
 766         DEFINEREG(BLC_PWM_CTL2),
 767
 768         DEFINEREG2(PP_CONTROL, i830_debug_pp_control),
 769         DEFINEREG2(PP_STATUS, i830_debug_pp_status),
 770         DEFINEREG(PP_ON_DELAYS),
 771         DEFINEREG(PP_OFF_DELAYS),
 772         DEFINEREG(PP_DIVISOR),
 773         DEFINEREG(PFIT_CONTROL),
 774         DEFINEREG(PFIT_PGM_RATIOS),
 775         DEFINEREG(PORT_HOTPLUG_EN),
 776         DEFINEREG(PORT_HOTPLUG_STAT),
 777
 778         DEFINEREG2(DSPACNTR, i830_debug_dspcntr),
 779         DEFINEREG2(DSPASTRIDE, i830_debug_dspstride),
 780         DEFINEREG2(DSPAPOS, i830_debug_xy),
 781         DEFINEREG2(DSPASIZE, i830_debug_xyminus1),
 782         DEFINEREG(DSPABASE),
 783         DEFINEREG(DSPASURF),
 784         DEFINEREG(DSPATILEOFF),
 785         DEFINEREG2(PIPEACONF, i830_debug_pipeconf),
 786         DEFINEREG2(PIPEASRC, i830_debug_yxminus1),
 787         DEFINEREG2(PIPEASTAT, i830_debug_pipestat),
 788         DEFINEREG(PIPEA_GMCH_DATA_M),
 789         DEFINEREG(PIPEA_GMCH_DATA_N),
 790         DEFINEREG(PIPEA_DP_LINK_M),
 791         DEFINEREG(PIPEA_DP_LINK_N),
 792         DEFINEREG(CURSOR_A_BASE),
 793         DEFINEREG(CURSOR_A_CONTROL),
 794         DEFINEREG(CURSOR_A_POSITION),
 795
 796         DEFINEREG2(FPA0, i830_debug_fp),
 797         DEFINEREG2(FPA1, i830_debug_fp),
 798         DEFINEREG2(DPLL_A, i830_debug_dpll),
 799         DEFINEREG(DPLL_A_MD),
 800         DEFINEREG2(HTOTAL_A, i830_debug_hvtotal),
 801         DEFINEREG2(HBLANK_A, i830_debug_hvsyncblank),
 802         DEFINEREG2(HSYNC_A, i830_debug_hvsyncblank),
 803         DEFINEREG2(VTOTAL_A, i830_debug_hvtotal),
 804         DEFINEREG2(VBLANK_A, i830_debug_hvsyncblank),
 805         DEFINEREG2(VSYNC_A, i830_debug_hvsyncblank),
 806         DEFINEREG(BCLRPAT_A),
 807         DEFINEREG(VSYNCSHIFT_A),
 808
 809         DEFINEREG2(DSPBCNTR, i830_debug_dspcntr),
 810         DEFINEREG2(DSPBSTRIDE, i830_debug_dspstride),
 811         DEFINEREG2(DSPBPOS, i830_debug_xy),
 812         DEFINEREG2(DSPBSIZE, i830_debug_xyminus1),
 813         DEFINEREG(DSPBBASE),
 814         DEFINEREG(DSPBSURF),
 815         DEFINEREG(DSPBTILEOFF),
 816         DEFINEREG2(PIPEBCONF, i830_debug_pipeconf),
 817         DEFINEREG2(PIPEBSRC, i830_debug_yxminus1),
 818         DEFINEREG2(PIPEBSTAT, i830_debug_pipestat),
 819         DEFINEREG(PIPEB_GMCH_DATA_M),
 820         DEFINEREG(PIPEB_GMCH_DATA_N),
 821         DEFINEREG(PIPEB_DP_LINK_M),
 822         DEFINEREG(PIPEB_DP_LINK_N),
 823         DEFINEREG(CURSOR_B_BASE),
 824         DEFINEREG(CURSOR_B_CONTROL),
 825         DEFINEREG(CURSOR_B_POSITION),
 826
 827         DEFINEREG2(FPB0, i830_debug_fp),
 828         DEFINEREG2(FPB1, i830_debug_fp),
 829         DEFINEREG2(DPLL_B, i830_debug_dpll),
 830         DEFINEREG(DPLL_B_MD),
 831         DEFINEREG2(HTOTAL_B, i830_debug_hvtotal),
 832         DEFINEREG2(HBLANK_B, i830_debug_hvsyncblank),
 833         DEFINEREG2(HSYNC_B, i830_debug_hvsyncblank),
 834         DEFINEREG2(VTOTAL_B, i830_debug_hvtotal),
 835         DEFINEREG2(VBLANK_B, i830_debug_hvsyncblank),
 836         DEFINEREG2(VSYNC_B, i830_debug_hvsyncblank),
 837         DEFINEREG(BCLRPAT_B),
 838         DEFINEREG(VSYNCSHIFT_B),
 839
 840         DEFINEREG(VCLK_DIVISOR_VGA0),
 841         DEFINEREG(VCLK_DIVISOR_VGA1),
 842         DEFINEREG(VCLK_POST_DIV),
 843         DEFINEREG2(VGACNTRL, i830_debug_vgacntrl),
 844
 845         DEFINEREG(TV_CTL),
 846         DEFINEREG(TV_DAC),
 847         DEFINEREG(TV_CSC_Y),
 848         DEFINEREG(TV_CSC_Y2),
 849         DEFINEREG(TV_CSC_U),
 850         DEFINEREG(TV_CSC_U2),
 851         DEFINEREG(TV_CSC_V),
 852         DEFINEREG(TV_CSC_V2),
 853         DEFINEREG(TV_CLR_KNOBS),
 854         DEFINEREG(TV_CLR_LEVEL),
 855         DEFINEREG(TV_H_CTL_1),
 856         DEFINEREG(TV_H_CTL_2),
 857         DEFINEREG(TV_H_CTL_3),
 858         DEFINEREG(TV_V_CTL_1),
 859         DEFINEREG(TV_V_CTL_2),
 860         DEFINEREG(TV_V_CTL_3),
 861         DEFINEREG(TV_V_CTL_4),
 862         DEFINEREG(TV_V_CTL_5),
 863         DEFINEREG(TV_V_CTL_6),
 864         DEFINEREG(TV_V_CTL_7),
 865         DEFINEREG(TV_SC_CTL_1),
 866         DEFINEREG(TV_SC_CTL_2),
 867         DEFINEREG(TV_SC_CTL_3),
 868         DEFINEREG(TV_WIN_POS),
 869         DEFINEREG(TV_WIN_SIZE),
 870         DEFINEREG(TV_FILTER_CTL_1),
 871         DEFINEREG(TV_FILTER_CTL_2),
 872         DEFINEREG(TV_FILTER_CTL_3),
 873         DEFINEREG(TV_CC_CONTROL),
 874         DEFINEREG(TV_CC_DATA),
 875         DEFINEREG(TV_H_LUMA_0),
 876         DEFINEREG(TV_H_LUMA_59),
 877         DEFINEREG(TV_H_CHROMA_0),
 878         DEFINEREG(TV_H_CHROMA_59),
 879
 880         DEFINEREG(FBC_CFB_BASE),
 881         DEFINEREG(FBC_LL_BASE),
 882         DEFINEREG(FBC_CONTROL),
 883         DEFINEREG(FBC_COMMAND),
 884         DEFINEREG(FBC_STATUS),
 885         DEFINEREG(FBC_CONTROL2),
 886         DEFINEREG(FBC_FENCE_OFF),
 887         DEFINEREG(FBC_MOD_NUM),
 888
 889         DEFINEREG(MI_MODE),
 890         /* DEFINEREG(MI_DISPLAY_POWER_DOWN), CRL only */
 891         DEFINEREG(MI_ARB_STATE),
 892         DEFINEREG(MI_RDRET_STATE),
 893         DEFINEREG(ECOSKPD),
 894
 895         DEFINEREG(DP_B),
 896         DEFINEREG(DPB_AUX_CH_CTL),
 897         DEFINEREG(DPB_AUX_CH_DATA1),
 898         DEFINEREG(DPB_AUX_CH_DATA2),
 899         DEFINEREG(DPB_AUX_CH_DATA3),
 900         DEFINEREG(DPB_AUX_CH_DATA4),
 901         DEFINEREG(DPB_AUX_CH_DATA5),
 902
 903         DEFINEREG(DP_C),
 904         DEFINEREG(DPC_AUX_CH_CTL),
 905         DEFINEREG(DPC_AUX_CH_DATA1),
 906         DEFINEREG(DPC_AUX_CH_DATA2),
 907         DEFINEREG(DPC_AUX_CH_DATA3),
 908         DEFINEREG(DPC_AUX_CH_DATA4),
 909         DEFINEREG(DPC_AUX_CH_DATA5),
 910
 911         DEFINEREG(DP_D),
 912         DEFINEREG(DPD_AUX_CH_CTL),
 913         DEFINEREG(DPD_AUX_CH_DATA1),
 914         DEFINEREG(DPD_AUX_CH_DATA2),
 915         DEFINEREG(DPD_AUX_CH_DATA3),
 916         DEFINEREG(DPD_AUX_CH_DATA4),
 917         DEFINEREG(DPD_AUX_CH_DATA5),
 918
 919         DEFINEREG(AUD_CONFIG),
 920         DEFINEREG(AUD_HDMIW_STATUS),
 921         DEFINEREG(AUD_CONV_CHCNT),
 922         DEFINEREG(VIDEO_DIP_CTL),
 923         DEFINEREG(AUD_PINW_CNTR),
 924         DEFINEREG(AUD_CNTL_ST),
 925         DEFINEREG(AUD_PIN_CAP),
 926         DEFINEREG(AUD_PINW_CAP),
 927         DEFINEREG(AUD_PINW_UNSOLRESP),
 928         DEFINEREG(AUD_OUT_DIG_CNVT),
 929         DEFINEREG(AUD_OUT_CWCAP),
 930         DEFINEREG(AUD_GRP_CAP),
 931
 932 #define DEFINEFENCE_915(i) \
 933         { FENCE+i*4, "FENCE  " #i, i810_debug_915_fence, 0 }
 934 #define DEFINEFENCE_945(i)                                              \
 935         { FENCE_NEW+(i - 8) * 4, "FENCE  " #i, i810_debug_915_fence, 0 }
 936
 937         DEFINEFENCE_915(0),
 938         DEFINEFENCE_915(1),
 939         DEFINEFENCE_915(2),
 940         DEFINEFENCE_915(3),
 941         DEFINEFENCE_915(4),
 942         DEFINEFENCE_915(5),
 943         DEFINEFENCE_915(6),
 944         DEFINEFENCE_915(7),
 945         DEFINEFENCE_945(8),
 946         DEFINEFENCE_945(9),
 947         DEFINEFENCE_945(10),
 948         DEFINEFENCE_945(11),
 949         DEFINEFENCE_945(12),
 950         DEFINEFENCE_945(13),
 951         DEFINEFENCE_945(14),
 952         DEFINEFENCE_945(15),
 953
 954 #define DEFINEFENCE_965(i) \
 955         { FENCE_NEW+i*8, "FENCE START " #i, i810_debug_965_fence_start, 0 }, \
 956         { FENCE_NEW+i*8+4, "FENCE END " #i, i810_debug_965_fence_end, 0 }
 957
 958         DEFINEFENCE_965(0),
 959         DEFINEFENCE_965(1),
 960         DEFINEFENCE_965(2),
 961         DEFINEFENCE_965(3),
 962         DEFINEFENCE_965(4),
 963         DEFINEFENCE_965(5),
 964         DEFINEFENCE_965(6),
 965         DEFINEFENCE_965(7),
 966         DEFINEFENCE_965(8),
 967         DEFINEFENCE_965(9),
 968         DEFINEFENCE_965(10),
 969         DEFINEFENCE_965(11),
 970         DEFINEFENCE_965(12),
 971         DEFINEFENCE_965(13),
 972         DEFINEFENCE_965(14),
 973         DEFINEFENCE_965(15),
 974
 975         DEFINEREG(INST_PM),
 976 };
 977
 978 DEBUGSTRING(ironlake_debug_rr_hw_ctl)
 979 {
 980         snprintf(result, len, "low %d, high %d", val & RR_HW_LOW_POWER_FRAMES_MASK,
 981                  (val & RR_HW_HIGH_POWER_FRAMES_MASK) >> 8);
 982 }
 983
 984 DEBUGSTRING(ironlake_debug_m_tu)
 985 {
 986         snprintf(result, len, "TU %d, val 0x%x %d", (val >> 25) + 1, val & 0xffffff,
 987                  val & 0xffffff);
 988 }
 989
 990 DEBUGSTRING(ironlake_debug_n)
 991 {
 992         snprintf(result, len, "val 0x%x %d", val & 0xffffff, val & 0xffffff);
 993 }
 994
 995 DEBUGSTRING(ironlake_debug_fdi_tx_ctl)
 996 {
 997         const char *train = NULL, *voltage = NULL, *pre_emphasis = NULL, *portw =
 998             NULL;
 999
1000         switch (val & FDI_LINK_TRAIN_NONE) {
1001         case FDI_LINK_TRAIN_PATTERN_1:
1002                 train = "pattern_1";
1003                 break;
1004         case FDI_LINK_TRAIN_PATTERN_2:
1005                 train = "pattern_2";
1006                 break;
1007         case FDI_LINK_TRAIN_PATTERN_IDLE:
1008                 train = "pattern_idle";
1009                 break;
1010         case FDI_LINK_TRAIN_NONE:
1011                 train = "not train";
1012                 break;
1013         }
1014
1015         if (HAS_CPT) {
1016                 /* SNB B0 */
1017                 switch (val & (0x3f << 22)) {
1018                 case FDI_LINK_TRAIN_400MV_0DB_SNB_B:
1019                         voltage = "0.4V";
1020                         pre_emphasis = "0dB";
1021                         break;
1022                 case FDI_LINK_TRAIN_400MV_6DB_SNB_B:
1023                         voltage = "0.4V";
1024                         pre_emphasis = "6dB";
1025                         break;
1026                 case FDI_LINK_TRAIN_600MV_3_5DB_SNB_B:
1027                         voltage = "0.6V";
1028                         pre_emphasis = "3.5dB";
1029                         break;
1030                 case FDI_LINK_TRAIN_800MV_0DB_SNB_B:
1031                         voltage = "0.8V";
1032                         pre_emphasis = "0dB";
1033                         break;
1034                 }
1035
1036         } else {
1037
1038                 switch (val & (7 << 25)) {
1039                         case FDI_LINK_TRAIN_VOLTAGE_0_4V:
1040                                 voltage = "0.4V";
1041                                 break;
1042                         case FDI_LINK_TRAIN_VOLTAGE_0_6V:
1043                                 voltage = "0.6V";
1044                                 break;
1045                         case FDI_LINK_TRAIN_VOLTAGE_0_8V:
1046                                 voltage = "0.8V";
1047                                 break;
1048                         case FDI_LINK_TRAIN_VOLTAGE_1_2V:
1049                                 voltage = "1.2V";
1050                                 break;
1051                         default:
1052                                 voltage = "reserved";
1053                 }
1054
1055                 switch (val & (7 << 22)) {
1056                         case FDI_LINK_TRAIN_PRE_EMPHASIS_NONE:
1057                                 pre_emphasis = "none";
1058                                 break;
1059                         case FDI_LINK_TRAIN_PRE_EMPHASIS_1_5X:
1060                                 pre_emphasis = "1.5x";
1061                                 break;
1062                         case FDI_LINK_TRAIN_PRE_EMPHASIS_2X:
1063                                 pre_emphasis = "2x";
1064                                 break;
1065                         case FDI_LINK_TRAIN_PRE_EMPHASIS_3X:
1066                                 pre_emphasis = "3x";
1067                                 break;
1068                         default:
1069                                 pre_emphasis = "reserved";
1070                 }
1071
1072         }
1073
1074         switch (val & (7 << 19)) {
1075         case FDI_DP_PORT_WIDTH_X1:
1076                 portw = "X1";
1077                 break;
1078         case FDI_DP_PORT_WIDTH_X2:
1079                 portw = "X2";
1080                 break;
1081         case FDI_DP_PORT_WIDTH_X3:
1082                 portw = "X3";
1083                 break;
1084         case FDI_DP_PORT_WIDTH_X4:
1085                 portw = "X4";
1086                 break;
1087         }
1088
1089         snprintf(result, len, "%s, train pattern %s, voltage swing %s,"
1090                  "pre-emphasis %s, port width %s, enhanced framing %s, FDI PLL %s, scrambing %s, master mode %s",
1091                  val & FDI_TX_ENABLE ? "enable" : "disable",
1092                  train, voltage, pre_emphasis, portw,
1093                  val & FDI_TX_ENHANCE_FRAME_ENABLE ? "enable" :
1094                  "disable",
1095                  val & FDI_TX_PLL_ENABLE ? "enable" : "disable",
1096                  val & (1 << 7) ? "disable" : "enable",
1097                  val & (1 << 0) ? "enable" : "disable");
1098 }
1099
1100 DEBUGSTRING(ironlake_debug_fdi_rx_ctl)
1101 {
1102         const char *train = NULL, *portw = NULL, *bpc = NULL;
1103
1104         if (HAS_CPT) {
1105                 switch (val & FDI_LINK_TRAIN_PATTERN_MASK_CPT) {
1106                 case FDI_LINK_TRAIN_PATTERN_1_CPT:
1107                         train = "pattern_1";
1108                         break;
1109                 case FDI_LINK_TRAIN_PATTERN_2_CPT:
1110                         train = "pattern_2";
1111                         break;
1112                 case FDI_LINK_TRAIN_PATTERN_IDLE_CPT:
1113                         train = "pattern_idle";
1114                         break;
1115                 case FDI_LINK_TRAIN_NORMAL_CPT:
1116                         train = "not train";
1117                         break;
1118                 }
1119         } else {
1120                 switch (val & FDI_LINK_TRAIN_NONE) {
1121                 case FDI_LINK_TRAIN_PATTERN_1:
1122                         train = "pattern_1";
1123                         break;
1124                 case FDI_LINK_TRAIN_PATTERN_2:
1125                         train = "pattern_2";
1126                         break;
1127                 case FDI_LINK_TRAIN_PATTERN_IDLE:
1128                         train = "pattern_idle";
1129                         break;
1130                 case FDI_LINK_TRAIN_NONE:
1131                         train = "not train";
1132                         break;
1133                 }
1134         }
1135
1136         switch (val & (7 << 19)) {
1137         case FDI_DP_PORT_WIDTH_X1:
1138                 portw = "X1";
1139                 break;
1140         case FDI_DP_PORT_WIDTH_X2:
1141                 portw = "X2";
1142                 break;
1143         case FDI_DP_PORT_WIDTH_X3:
1144                 portw = "X3";
1145                 break;
1146         case FDI_DP_PORT_WIDTH_X4:
1147                 portw = "X4";
1148                 break;
1149         }
1150
1151         switch (val & (7 << 16)) {
1152         case FDI_8BPC:
1153                 bpc = "8bpc";
1154                 break;
1155         case FDI_10BPC:
1156                 bpc = "10bpc";
1157                 break;
1158         case FDI_6BPC:
1159                 bpc = "6bpc";
1160                 break;
1161         case FDI_12BPC:
1162                 bpc = "12bpc";
1163                 break;
1164         }
1165
1166         snprintf(result, len, "%s, train pattern %s, port width %s, %s,"
1167                  "link_reverse_strap_overwrite %s, dmi_link_reverse %s, FDI PLL %s,"
1168                  "FS ecc %s, FE ecc %s, FS err report %s, FE err report %s,"
1169                  "scrambing %s, enhanced framing %s, %s",
1170                  val & FDI_RX_ENABLE ? "enable" : "disable",
1171                  train, portw, bpc,
1172                  val & FDI_LINK_REVERSE_OVERWRITE ? "yes" : "no",
1173                  val & FDI_DMI_LINK_REVERSE_MASK ? "yes" : "no",
1174                  val & FDI_RX_PLL_ENABLE ? "enable" : "disable",
1175                  val & FDI_FS_ERR_CORRECT_ENABLE ? "enable" : "disable",
1176                  val & FDI_FE_ERR_CORRECT_ENABLE ? "enable" : "disable",
1177                  val & FDI_FS_ERR_REPORT_ENABLE ? "enable" : "disable",
1178                  val & FDI_FE_ERR_REPORT_ENABLE ? "enable" : "disable",
1179                  val & (1 << 7) ? "disable" : "enable",
1180                  val & FDI_RX_ENHANCE_FRAME_ENABLE ? "enable" :
1181                  "disable", val & FDI_SEL_PCDCLK ? "PCDClk" : "RawClk");
1182 }
1183
1184 DEBUGSTRING(ironlake_debug_dspstride)
1185 {
1186         snprintf(result, len, "%d", val >> 6);
1187 }
1188
1189 DEBUGSTRING(ironlake_debug_pch_dpll)
1190 {
1191         const char *enable = val & DPLL_VCO_ENABLE ? "enable" : "disable";
1192         const char *highspeed = val & DPLL_DVO_HIGH_SPEED ? "yes" : "no";
1193         const char *mode = NULL;
1194         const char *p2 = NULL;
1195         int fpa0_p1, fpa1_p1;
1196         const char *refclk = NULL;
1197         int sdvo_mul;
1198
1199         if ((val & DPLLB_MODE_LVDS) == DPLLB_MODE_LVDS) {
1200                 mode = "LVDS";
1201                 if (val & DPLLB_LVDS_P2_CLOCK_DIV_7)
1202                         p2 = "Div 7";
1203                 else
1204                         p2 = "Div 14";
1205         } else if ((val & DPLLB_MODE_LVDS) == DPLLB_MODE_DAC_SERIAL) {
1206                 mode = "Non-LVDS";
1207                 if (val & DPLL_DAC_SERIAL_P2_CLOCK_DIV_5)
1208                         p2 = "Div 5";
1209                 else
1210                         p2 = "Div 10";
1211         }
1212         fpa0_p1 = ffs((val & DPLL_FPA01_P1_POST_DIV_MASK) >> 16);
1213         fpa1_p1 = ffs((val & DPLL_FPA1_P1_POST_DIV_MASK));
1214
1215         switch (val & PLL_REF_INPUT_MASK) {
1216         case PLL_REF_INPUT_DREFCLK:
1217                 refclk = "default 120Mhz";
1218                 break;
1219         case PLL_REF_INPUT_SUPER_SSC:
1220                 refclk = "SuperSSC 120Mhz";
1221                 break;
1222         case PLL_REF_INPUT_TVCLKINBC:
1223                 refclk = "SDVO TVClkIn";
1224                 break;
1225         case PLLB_REF_INPUT_SPREADSPECTRUMIN:
1226                 refclk = "SSC";
1227                 break;
1228         case PLL_REF_INPUT_DMICLK:
1229                 refclk = "DMI RefCLK";
1230                 break;
1231         }
1232
1233         sdvo_mul = ((val & PLL_REF_SDVO_HDMI_MULTIPLIER_MASK) >> 9) + 1;
1234
1235         snprintf(result, len, "%s, sdvo high speed %s, mode %s, p2 %s, "
1236                  "FPA0 P1 %d, FPA1 P1 %d, refclk %s, sdvo/hdmi mul %d",
1237                  enable, highspeed, mode, p2, fpa0_p1, fpa1_p1, refclk,
1238                  sdvo_mul);
1239 }
1240
1241 DEBUGSTRING(ironlake_debug_dref_ctl)
1242 {
1243         const char *cpu_source;
1244         const char *ssc_source = val & DREF_SSC_SOURCE_ENABLE ? "enable" : "disable";
1245         const char *nonspread_source =
1246             val & DREF_NONSPREAD_SOURCE_ENABLE ? "enable" : "disable";
1247         const char *superspread_source =
1248             val & DREF_SUPERSPREAD_SOURCE_ENABLE ? "enable" : "disable";
1249         const char *ssc4_mode =
1250             val & DREF_SSC4_CENTERSPREAD ? "centerspread" : "downspread";
1251         const char *ssc1 = val & DREF_SSC1_ENABLE ? "enable" : "disable";
1252         const char *ssc4 = val & DREF_SSC4_ENABLE ? "enable" : "disable";
1253
1254         switch (val & DREF_CPU_SOURCE_OUTPUT_NONSPREAD) {
1255         case DREF_CPU_SOURCE_OUTPUT_DISABLE:
1256                 cpu_source = "disable";
1257                 break;
1258         case DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD:
1259                 cpu_source = "downspread";
1260                 break;
1261         case DREF_CPU_SOURCE_OUTPUT_NONSPREAD:
1262                 cpu_source = "nonspread";
1263                 break;
1264         default:
1265                 cpu_source = "reserved";
1266         }
1267         snprintf(result, len, "cpu source %s, ssc_source %s, nonspread_source %s, "
1268                  "superspread_source %s, ssc4_mode %s, ssc1 %s, ssc4 %s",
1269                  cpu_source, ssc_source, nonspread_source,
1270                  superspread_source, ssc4_mode, ssc1, ssc4);
1271 }
1272
1273 DEBUGSTRING(ironlake_debug_rawclk_freq)
1274 {
1275         const char *tp1 = NULL, *tp2 = NULL;
1276
1277         switch (val & FDL_TP1_TIMER_MASK) {
1278         case 0:
1279                 tp1 = "0.5us";
1280                 break;
1281         case (1 << 12):
1282                 tp1 = "1.0us";
1283                 break;
1284         case (2 << 12):
1285                 tp1 = "2.0us";
1286                 break;
1287         case (3 << 12):
1288                 tp1 = "4.0us";
1289                 break;
1290         }
1291         switch (val & FDL_TP2_TIMER_MASK) {
1292         case 0:
1293                 tp2 = "1.5us";
1294                 break;
1295         case (1 << 10):
1296                 tp2 = "3.0us";
1297                 break;
1298         case (2 << 10):
1299                 tp2 = "6.0us";
1300                 break;
1301         case (3 << 10):
1302                 tp2 = "12.0us";
1303                 break;
1304         }
1305         snprintf(result, len, "FDL_TP1 timer %s, FDL_TP2 timer %s, freq %d",
1306                  tp1, tp2, val & RAWCLK_FREQ_MASK);
1307
1308 }
1309
1310 DEBUGSTRING(ironlake_debug_fdi_rx_misc)
1311 {
1312         snprintf(result, len, "FDI Delay %d", val & ((1 << 13) - 1));
1313 }
1314
1315 DEBUGSTRING(ironlake_debug_transconf)
1316 {
1317         const char *enable = val & TRANS_ENABLE ? "enable" : "disable";
1318         const char *state = val & TRANS_STATE_ENABLE ? "active" : "inactive";
1319         const char *interlace;
1320
1321         switch ((val >> 21) & 7) {
1322         case 0:
1323                 interlace = "progressive";
1324                 break;
1325         case 2:
1326                 if (IS_GEN5(devid))
1327                         interlace = "interlaced sdvo";
1328                 else
1329                         interlace = "rsvd";
1330                 break;
1331         case 3:
1332                 interlace = "interlaced";
1333                 break;
1334         default:
1335                 interlace = "rsvd";
1336         }
1337
1338         snprintf(result, len, "%s, %s, %s", enable, state, interlace);
1339 }
1340
1341 DEBUGSTRING(ironlake_debug_panel_fitting)
1342 {
1343         const char *vadapt = NULL, *filter_sel = NULL;
1344
1345         switch (val & (3 << 25)) {
1346         case 0:
1347                 vadapt = "least";
1348                 break;
1349         case (1 << 25):
1350                 vadapt = "moderate";
1351                 break;
1352         case (2 << 25):
1353                 vadapt = "reserved";
1354                 break;
1355         case (3 << 25):
1356                 vadapt = "most";
1357                 break;
1358         }
1359
1360         switch (val & (3 << 23)) {
1361         case 0:
1362                 filter_sel = "programmed";
1363                 break;
1364         case (1 << 23):
1365                 filter_sel = "hardcoded";
1366                 break;
1367         case (2 << 23):
1368                 filter_sel = "edge_enhance";
1369                 break;
1370         case (3 << 23):
1371                 filter_sel = "edge_soften";
1372                 break;
1373         }
1374
1375         snprintf(result, len,
1376                  "%s, auto_scale %s, auto_scale_cal %s, v_filter %s, vadapt %s, mode %s, filter_sel %s,"
1377                  "chroma pre-filter %s, vert3tap %s, v_inter_invert %s",
1378                  val & PF_ENABLE ? "enable" : "disable",
1379                  val & (1 << 30) ? "no" : "yes",
1380                  val & (1 << 29) ? "yes" : "no",
1381                  val & (1 << 28) ? "bypass" : "enable",
1382                  val & (1 << 27) ? "enable" : "disable",
1383                  vadapt,
1384                  filter_sel,
1385                  val & (1 << 22) ? "enable" : "disable",
1386                  val & (1 << 21) ? "force" : "auto",
1387                  val & (1 << 20) ? "field 0" : "field 1");
1388 }
1389
1390 DEBUGSTRING(ironlake_debug_panel_fitting_2)
1391 {
1392         snprintf(result, len,
1393                  "vscale %f",
1394                  val / (float) (1<<15));
1395 }
1396
1397 DEBUGSTRING(ironlake_debug_panel_fitting_3)
1398 {
1399         snprintf(result, len,
1400                  "vscale initial phase %f",
1401                  val / (float) (1<<15));
1402 }
1403
1404 DEBUGSTRING(ironlake_debug_panel_fitting_4)
1405 {
1406         snprintf(result, len,
1407                  "hscale %f",
1408                  val / (float) (1<<15));
1409 }
1410
1411 DEBUGSTRING(ironlake_debug_pf_win)
1412 {
1413         int a, b;
1414
1415         a = (val >> 16) & 0x1fff;
1416         b = val & 0xfff;
1417
1418         snprintf(result, len, "%d, %d", a, b);
1419 }
1420
1421 DEBUGSTRING(ironlake_debug_hdmi)
1422 {
1423         int disp_pipe;
1424         const char *enable, *bpc = NULL, *encoding;
1425         const char *mode, *audio, *vsync, *hsync, *detect;
1426
1427         if (val & PORT_ENABLE)
1428                 enable = "enabled";
1429         else
1430                 enable = "disabled";
1431
1432         if (HAS_CPT)
1433                 disp_pipe = (val & (3<<29)) >> 29;
1434         else
1435                 disp_pipe = (val & TRANSCODER_B) >> 29;
1436
1437         switch (val & (7 << 26)) {
1438         case COLOR_FORMAT_8bpc:
1439                 bpc = "8bpc";
1440                 break;
1441         case COLOR_FORMAT_12bpc:
1442                 bpc = "12bpc";
1443                 break;
1444         }
1445
1446         if ((val & (3 << 10)) == TMDS_ENCODING)
1447                 encoding = "TMDS";
1448         else
1449                 encoding = "SDVO";
1450
1451         if (val & (1 << 9))
1452                 mode = "HDMI";
1453         else
1454                 mode = "DVI";
1455
1456         if (val & AUDIO_ENABLE)
1457                 audio = "enabled";
1458         else
1459                 audio = "disabled";
1460
1461         if (val & VSYNC_ACTIVE_HIGH)
1462                 vsync = "+vsync";
1463         else
1464                 vsync = "-vsync";
1465
1466         if (val & HSYNC_ACTIVE_HIGH)
1467                 hsync = "+hsync";
1468         else
1469                 hsync = "-hsync";
1470
1471         if (val & PORT_DETECTED)
1472                 detect = "detected";
1473         else
1474                 detect = "non-detected";
1475
1476         snprintf(result, len, "%s pipe %c %s %s %s audio %s %s %s %s",
1477                  enable, disp_pipe + 'A', bpc, encoding, mode, audio, vsync, hsync, detect);
1478 }
1479
1480 DEBUGSTRING(snb_debug_dpll_sel)
1481 {
1482         const char *transa, *transb;
1483         const char *dplla = NULL, *dpllb = NULL;
1484
1485         if (!HAS_CPT)
1486                 return;
1487
1488         if (val & TRANSA_DPLL_ENABLE) {
1489                 transa = "enable";
1490                 if (val & TRANSA_DPLLB_SEL)
1491                         dplla = "B";
1492                 else
1493                         dplla = "A";
1494         } else
1495                 transa = "disable";
1496
1497         if (val & TRANSB_DPLL_ENABLE) {
1498                 transb = "enable";
1499                 if (val & TRANSB_DPLLB_SEL)
1500                         dpllb = "B";
1501                 else
1502                         dpllb = "A";
1503         } else
1504                 transb = "disable";
1505
1506         snprintf(result, len, "TransA DPLL %s (DPLL %s), TransB DPLL %s (DPLL %s)",
1507                  transa, dplla, transb, dpllb);
1508 }
1509
1510 DEBUGSTRING(snb_debug_trans_dp_ctl)
1511 {
1512         const char *enable, *port = NULL, *bpc = NULL, *vsync, *hsync;
1513
1514         if (!HAS_CPT)
1515                 return;
1516
1517         if (val & TRANS_DP_OUTPUT_ENABLE)
1518                 enable = "enable";
1519         else
1520                 enable = "disable";
1521
1522         switch (val & TRANS_DP_PORT_SEL_MASK) {
1523         case TRANS_DP_PORT_SEL_B:
1524                 port = "B";
1525                 break;
1526         case TRANS_DP_PORT_SEL_C:
1527                 port = "C";
1528                 break;
1529         case TRANS_DP_PORT_SEL_D:
1530                 port = "D";
1531                 break;
1532         default:
1533                 port = "none";
1534                 break;
1535         }
1536
1537         switch (val & (7<<9)) {
1538         case TRANS_DP_8BPC:
1539                 bpc = "8bpc";
1540                 break;
1541         case TRANS_DP_10BPC:
1542                 bpc = "10bpc";
1543                 break;
1544         case TRANS_DP_6BPC:
1545                 bpc = "6bpc";
1546                 break;
1547         case TRANS_DP_12BPC:
1548                 bpc = "12bpc";
1549                 break;
1550         }
1551
1552         if (val & TRANS_DP_VSYNC_ACTIVE_HIGH)
1553                 vsync = "+vsync";
1554         else
1555                 vsync = "-vsync";
1556
1557         if (val & TRANS_DP_HSYNC_ACTIVE_HIGH)
1558                 hsync = "+hsync";
1559         else
1560                 hsync = "-hsync";
1561
1562         snprintf(result, len, "%s port %s %s %s %s",
1563                  enable, port, bpc, vsync, hsync);
1564 }
1565
1566 DEBUGSTRING(ilk_debug_pp_control)
1567 {
1568         snprintf(result, len, "blacklight %s, %spower down on reset, panel %s",
1569                  (val & (1 << 2)) ? "enabled" : "disabled",
1570                  (val & (1 << 1)) ? "" : "do not ",
1571                  (val & (1 << 0)) ? "on" : "off");
1572 }
1573
1574 static struct reg_debug ironlake_debug_regs[] = {
1575         DEFINEREG(PGETBL_CTL),
1576         DEFINEREG(GEN6_INSTDONE_1),
1577         DEFINEREG(GEN6_INSTDONE_2),
1578         DEFINEREG2(CPU_VGACNTRL, i830_debug_vgacntrl),
1579         DEFINEREG(DIGITAL_PORT_HOTPLUG_CNTRL),
1580
1581         DEFINEREG2(RR_HW_CTL, ironlake_debug_rr_hw_ctl),
1582
1583         DEFINEREG(FDI_PLL_BIOS_0),
1584         DEFINEREG(FDI_PLL_BIOS_1),
1585         DEFINEREG(FDI_PLL_BIOS_2),
1586
1587         DEFINEREG(DISPLAY_PORT_PLL_BIOS_0),
1588         DEFINEREG(DISPLAY_PORT_PLL_BIOS_1),
1589         DEFINEREG(DISPLAY_PORT_PLL_BIOS_2),
1590
1591         DEFINEREG(FDI_PLL_FREQ_CTL),
1592
1593         /* pipe B */
1594
1595         DEFINEREG2(PIPEACONF, i830_debug_pipeconf),
1596
1597         DEFINEREG2(HTOTAL_A, i830_debug_hvtotal),
1598         DEFINEREG2(HBLANK_A, i830_debug_hvsyncblank),
1599         DEFINEREG2(HSYNC_A, i830_debug_hvsyncblank),
1600         DEFINEREG2(VTOTAL_A, i830_debug_hvtotal),
1601         DEFINEREG2(VBLANK_A, i830_debug_hvsyncblank),
1602         DEFINEREG2(VSYNC_A, i830_debug_hvsyncblank),
1603         DEFINEREG(VSYNCSHIFT_A),
1604         DEFINEREG2(PIPEASRC, i830_debug_yxminus1),
1605
1606         DEFINEREG2(PIPEA_DATA_M1, ironlake_debug_m_tu),
1607         DEFINEREG2(PIPEA_DATA_N1, ironlake_debug_n),
1608         DEFINEREG2(PIPEA_DATA_M2, ironlake_debug_m_tu),
1609         DEFINEREG2(PIPEA_DATA_N2, ironlake_debug_n),
1610
1611         DEFINEREG2(PIPEA_LINK_M1, ironlake_debug_n),
1612         DEFINEREG2(PIPEA_LINK_N1, ironlake_debug_n),
1613         DEFINEREG2(PIPEA_LINK_M2, ironlake_debug_n),
1614         DEFINEREG2(PIPEA_LINK_N2, ironlake_debug_n),
1615
1616         DEFINEREG2(DSPACNTR, i830_debug_dspcntr),
1617         DEFINEREG(DSPABASE),
1618         DEFINEREG2(DSPASTRIDE, ironlake_debug_dspstride),
1619         DEFINEREG(DSPASURF),
1620         DEFINEREG2(DSPATILEOFF, i830_debug_xy),
1621
1622         /* pipe B */
1623
1624         DEFINEREG2(PIPEBCONF, i830_debug_pipeconf),
1625
1626         DEFINEREG2(HTOTAL_B, i830_debug_hvtotal),
1627         DEFINEREG2(HBLANK_B, i830_debug_hvsyncblank),
1628         DEFINEREG2(HSYNC_B, i830_debug_hvsyncblank),
1629         DEFINEREG2(VTOTAL_B, i830_debug_hvtotal),
1630         DEFINEREG2(VBLANK_B, i830_debug_hvsyncblank),
1631         DEFINEREG2(VSYNC_B, i830_debug_hvsyncblank),
1632         DEFINEREG(VSYNCSHIFT_B),
1633         DEFINEREG2(PIPEBSRC, i830_debug_yxminus1),
1634
1635         DEFINEREG2(PIPEB_DATA_M1, ironlake_debug_m_tu),
1636         DEFINEREG2(PIPEB_DATA_N1, ironlake_debug_n),
1637         DEFINEREG2(PIPEB_DATA_M2, ironlake_debug_m_tu),
1638         DEFINEREG2(PIPEB_DATA_N2, ironlake_debug_n),
1639
1640         DEFINEREG2(PIPEB_LINK_M1, ironlake_debug_n),
1641         DEFINEREG2(PIPEB_LINK_N1, ironlake_debug_n),
1642         DEFINEREG2(PIPEB_LINK_M2, ironlake_debug_n),
1643         DEFINEREG2(PIPEB_LINK_N2, ironlake_debug_n),
1644
1645         DEFINEREG2(DSPBCNTR, i830_debug_dspcntr),
1646         DEFINEREG(DSPBBASE),
1647         DEFINEREG2(DSPBSTRIDE, ironlake_debug_dspstride),
1648         DEFINEREG(DSPBSURF),
1649         DEFINEREG2(DSPBTILEOFF, i830_debug_xy),
1650
1651         /* pipe C */
1652
1653         DEFINEREG2(PIPECCONF, i830_debug_pipeconf),
1654
1655         DEFINEREG2(HTOTAL_C, i830_debug_hvtotal),
1656         DEFINEREG2(HBLANK_C, i830_debug_hvsyncblank),
1657         DEFINEREG2(HSYNC_C, i830_debug_hvsyncblank),
1658         DEFINEREG2(VTOTAL_C, i830_debug_hvtotal),
1659         DEFINEREG2(VBLANK_C, i830_debug_hvsyncblank),
1660         DEFINEREG2(VSYNC_C, i830_debug_hvsyncblank),
1661         DEFINEREG(VSYNCSHIFT_C),
1662         DEFINEREG2(PIPECSRC, i830_debug_yxminus1),
1663
1664         DEFINEREG2(PIPEC_DATA_M1, ironlake_debug_m_tu),
1665         DEFINEREG2(PIPEC_DATA_N1, ironlake_debug_n),
1666         DEFINEREG2(PIPEC_DATA_M2, ironlake_debug_m_tu),
1667         DEFINEREG2(PIPEC_DATA_N2, ironlake_debug_n),
1668
1669         DEFINEREG2(PIPEC_LINK_M1, ironlake_debug_n),
1670         DEFINEREG2(PIPEC_LINK_N1, ironlake_debug_n),
1671         DEFINEREG2(PIPEC_LINK_M2, ironlake_debug_n),
1672         DEFINEREG2(PIPEC_LINK_N2, ironlake_debug_n),
1673
1674         DEFINEREG2(DSPCCNTR, i830_debug_dspcntr),
1675         DEFINEREG(DSPCBASE),
1676         DEFINEREG2(DSPCSTRIDE, ironlake_debug_dspstride),
1677         DEFINEREG(DSPCSURF),
1678         DEFINEREG2(DSPCTILEOFF, i830_debug_xy),
1679
1680         /* Panel fitter */
1681
1682         DEFINEREG2(PFA_CTL_1, ironlake_debug_panel_fitting),
1683         DEFINEREG2(PFA_CTL_2, ironlake_debug_panel_fitting_2),
1684         DEFINEREG2(PFA_CTL_3, ironlake_debug_panel_fitting_3),
1685         DEFINEREG2(PFA_CTL_4, ironlake_debug_panel_fitting_4),
1686         DEFINEREG2(PFA_WIN_POS, ironlake_debug_pf_win),
1687         DEFINEREG2(PFA_WIN_SIZE, ironlake_debug_pf_win),
1688         DEFINEREG2(PFB_CTL_1, ironlake_debug_panel_fitting),
1689         DEFINEREG2(PFB_CTL_2, ironlake_debug_panel_fitting_2),
1690         DEFINEREG2(PFB_CTL_3, ironlake_debug_panel_fitting_3),
1691         DEFINEREG2(PFB_CTL_4, ironlake_debug_panel_fitting_4),
1692         DEFINEREG2(PFB_WIN_POS, ironlake_debug_pf_win),
1693         DEFINEREG2(PFB_WIN_SIZE, ironlake_debug_pf_win),
1694         DEFINEREG2(PFC_CTL_1, ironlake_debug_panel_fitting),
1695         DEFINEREG2(PFC_CTL_2, ironlake_debug_panel_fitting_2),
1696         DEFINEREG2(PFC_CTL_3, ironlake_debug_panel_fitting_3),
1697         DEFINEREG2(PFC_CTL_4, ironlake_debug_panel_fitting_4),
1698         DEFINEREG2(PFC_WIN_POS, ironlake_debug_pf_win),
1699         DEFINEREG2(PFC_WIN_SIZE, ironlake_debug_pf_win),
1700
1701         /* PCH */
1702
1703         DEFINEREG2(PCH_DREF_CONTROL, ironlake_debug_dref_ctl),
1704         DEFINEREG2(PCH_RAWCLK_FREQ, ironlake_debug_rawclk_freq),
1705         DEFINEREG(PCH_DPLL_TMR_CFG),
1706         DEFINEREG(PCH_SSC4_PARMS),
1707         DEFINEREG(PCH_SSC4_AUX_PARMS),
1708         DEFINEREG2(PCH_DPLL_SEL, snb_debug_dpll_sel),
1709         DEFINEREG(PCH_DPLL_ANALOG_CTL),
1710
1711         DEFINEREG2(PCH_DPLL_A, ironlake_debug_pch_dpll),
1712         DEFINEREG2(PCH_DPLL_B, ironlake_debug_pch_dpll),
1713         DEFINEREG2(PCH_FPA0, i830_debug_fp),
1714         DEFINEREG2(PCH_FPA1, i830_debug_fp),
1715         DEFINEREG2(PCH_FPB0, i830_debug_fp),
1716         DEFINEREG2(PCH_FPB1, i830_debug_fp),
1717
1718         DEFINEREG2(TRANS_HTOTAL_A, i830_debug_hvtotal),
1719         DEFINEREG2(TRANS_HBLANK_A, i830_debug_hvsyncblank),
1720         DEFINEREG2(TRANS_HSYNC_A, i830_debug_hvsyncblank),
1721         DEFINEREG2(TRANS_VTOTAL_A, i830_debug_hvtotal),
1722         DEFINEREG2(TRANS_VBLANK_A, i830_debug_hvsyncblank),
1723         DEFINEREG2(TRANS_VSYNC_A, i830_debug_hvsyncblank),
1724         DEFINEREG(TRANS_VSYNCSHIFT_A),
1725
1726         DEFINEREG2(TRANSA_DATA_M1, ironlake_debug_m_tu),
1727         DEFINEREG2(TRANSA_DATA_N1, ironlake_debug_n),
1728         DEFINEREG2(TRANSA_DATA_M2, ironlake_debug_m_tu),
1729         DEFINEREG2(TRANSA_DATA_N2, ironlake_debug_n),
1730         DEFINEREG2(TRANSA_DP_LINK_M1, ironlake_debug_n),
1731         DEFINEREG2(TRANSA_DP_LINK_N1, ironlake_debug_n),
1732         DEFINEREG2(TRANSA_DP_LINK_M2, ironlake_debug_n),
1733         DEFINEREG2(TRANSA_DP_LINK_N2, ironlake_debug_n),
1734
1735         DEFINEREG2(TRANS_HTOTAL_B, i830_debug_hvtotal),
1736         DEFINEREG2(TRANS_HBLANK_B, i830_debug_hvsyncblank),
1737         DEFINEREG2(TRANS_HSYNC_B, i830_debug_hvsyncblank),
1738         DEFINEREG2(TRANS_VTOTAL_B, i830_debug_hvtotal),
1739         DEFINEREG2(TRANS_VBLANK_B, i830_debug_hvsyncblank),
1740         DEFINEREG2(TRANS_VSYNC_B, i830_debug_hvsyncblank),
1741         DEFINEREG(TRANS_VSYNCSHIFT_B),
1742
1743         DEFINEREG2(TRANSB_DATA_M1, ironlake_debug_m_tu),
1744         DEFINEREG2(TRANSB_DATA_N1, ironlake_debug_n),
1745         DEFINEREG2(TRANSB_DATA_M2, ironlake_debug_m_tu),
1746         DEFINEREG2(TRANSB_DATA_N2, ironlake_debug_n),
1747         DEFINEREG2(TRANSB_DP_LINK_M1, ironlake_debug_n),
1748         DEFINEREG2(TRANSB_DP_LINK_N1, ironlake_debug_n),
1749         DEFINEREG2(TRANSB_DP_LINK_M2, ironlake_debug_n),
1750         DEFINEREG2(TRANSB_DP_LINK_N2, ironlake_debug_n),
1751
1752         DEFINEREG2(TRANS_HTOTAL_C, i830_debug_hvtotal),
1753         DEFINEREG2(TRANS_HBLANK_C, i830_debug_hvsyncblank),
1754         DEFINEREG2(TRANS_HSYNC_C, i830_debug_hvsyncblank),
1755         DEFINEREG2(TRANS_VTOTAL_C, i830_debug_hvtotal),
1756         DEFINEREG2(TRANS_VBLANK_C, i830_debug_hvsyncblank),
1757         DEFINEREG2(TRANS_VSYNC_C, i830_debug_hvsyncblank),
1758         DEFINEREG(TRANS_VSYNCSHIFT_C),
1759
1760         DEFINEREG2(TRANSC_DATA_M1, ironlake_debug_m_tu),
1761         DEFINEREG2(TRANSC_DATA_N1, ironlake_debug_n),
1762         DEFINEREG2(TRANSC_DATA_M2, ironlake_debug_m_tu),
1763         DEFINEREG2(TRANSC_DATA_N2, ironlake_debug_n),
1764         DEFINEREG2(TRANSC_DP_LINK_M1, ironlake_debug_n),
1765         DEFINEREG2(TRANSC_DP_LINK_N1, ironlake_debug_n),
1766         DEFINEREG2(TRANSC_DP_LINK_M2, ironlake_debug_n),
1767         DEFINEREG2(TRANSC_DP_LINK_N2, ironlake_debug_n),
1768
1769         DEFINEREG2(TRANSACONF, ironlake_debug_transconf),
1770         DEFINEREG2(TRANSBCONF, ironlake_debug_transconf),
1771         DEFINEREG2(TRANSCCONF, ironlake_debug_transconf),
1772
1773         DEFINEREG2(FDI_TXA_CTL, ironlake_debug_fdi_tx_ctl),
1774         DEFINEREG2(FDI_TXB_CTL, ironlake_debug_fdi_tx_ctl),
1775         DEFINEREG2(FDI_TXC_CTL, ironlake_debug_fdi_tx_ctl),
1776         DEFINEREG2(FDI_RXA_CTL, ironlake_debug_fdi_rx_ctl),
1777         DEFINEREG2(FDI_RXB_CTL, ironlake_debug_fdi_rx_ctl),
1778         DEFINEREG2(FDI_RXC_CTL, ironlake_debug_fdi_rx_ctl),
1779
1780         DEFINEREG2(FDI_RXA_MISC, ironlake_debug_fdi_rx_misc),
1781         DEFINEREG2(FDI_RXB_MISC, ironlake_debug_fdi_rx_misc),
1782         DEFINEREG2(FDI_RXC_MISC, ironlake_debug_fdi_rx_misc),
1783         DEFINEREG(FDI_RXA_TUSIZE1),
1784         DEFINEREG(FDI_RXA_TUSIZE2),
1785         DEFINEREG(FDI_RXB_TUSIZE1),
1786         DEFINEREG(FDI_RXB_TUSIZE2),
1787         DEFINEREG(FDI_RXC_TUSIZE1),
1788         DEFINEREG(FDI_RXC_TUSIZE2),
1789
1790         DEFINEREG(FDI_PLL_CTL_1),
1791         DEFINEREG(FDI_PLL_CTL_2),
1792
1793         DEFINEREG(FDI_RXA_IIR),
1794         DEFINEREG(FDI_RXA_IMR),
1795         DEFINEREG(FDI_RXB_IIR),
1796         DEFINEREG(FDI_RXB_IMR),
1797
1798         DEFINEREG2(PCH_ADPA, i830_debug_adpa),
1799         DEFINEREG2(HDMIB, ironlake_debug_hdmi),
1800         DEFINEREG2(HDMIC, ironlake_debug_hdmi),
1801         DEFINEREG2(HDMID, ironlake_debug_hdmi),
1802         DEFINEREG2(PCH_LVDS, i830_debug_lvds),
1803         DEFINEREG(CPU_eDP_A),
1804         DEFINEREG(PCH_DP_B),
1805         DEFINEREG(PCH_DP_C),
1806         DEFINEREG(PCH_DP_D),
1807         DEFINEREG2(TRANS_DP_CTL_A, snb_debug_trans_dp_ctl),
1808         DEFINEREG2(TRANS_DP_CTL_B, snb_debug_trans_dp_ctl),
1809         DEFINEREG2(TRANS_DP_CTL_C, snb_debug_trans_dp_ctl),
1810
1811         DEFINEREG(BLC_PWM_CPU_CTL2),
1812         DEFINEREG(BLC_PWM_CPU_CTL),
1813         DEFINEREG(BLC_PWM_PCH_CTL1),
1814         DEFINEREG(BLC_PWM_PCH_CTL2),
1815
1816         DEFINEREG2(PCH_PP_STATUS, i830_debug_pp_status),
1817         DEFINEREG2(PCH_PP_CONTROL, ilk_debug_pp_control),
1818         DEFINEREG(PCH_PP_ON_DELAYS),
1819         DEFINEREG(PCH_PP_OFF_DELAYS),
1820         DEFINEREG(PCH_PP_DIVISOR),
1821
1822         DEFINEREG2(PORT_DBG, ivb_debug_port),
1823
1824         DEFINEREG(RC6_RESIDENCY_TIME),
1825         DEFINEREG(RC6p_RESIDENCY_TIME),
1826         DEFINEREG(RC6pp_RESIDENCY_TIME),
1827 };
1828
1829 static struct reg_debug haswell_debug_regs[] = {
1830         /* Power wells */
1831         DEFINEREG(HSW_PWR_WELL_CTL1),
1832         DEFINEREG(HSW_PWR_WELL_CTL2),
1833         DEFINEREG(HSW_PWR_WELL_CTL3),
1834         DEFINEREG(HSW_PWR_WELL_CTL4),
1835         DEFINEREG(HSW_PWR_WELL_CTL5),
1836         DEFINEREG(HSW_PWR_WELL_CTL6),
1837
1838         /* DDI pipe function */
1839         DEFINEREG(PIPE_DDI_FUNC_CTL_A),
1840         DEFINEREG(PIPE_DDI_FUNC_CTL_B),
1841         DEFINEREG(PIPE_DDI_FUNC_CTL_C),
1842         DEFINEREG(PIPE_DDI_FUNC_CTL_EDP),
1843
1844         /* DP transport control */
1845         DEFINEREG(DP_TP_CTL_A),
1846         DEFINEREG(DP_TP_CTL_B),
1847         DEFINEREG(DP_TP_CTL_C),
1848         DEFINEREG(DP_TP_CTL_D),
1849         DEFINEREG(DP_TP_CTL_E),
1850
1851         /* DP status */
1852         DEFINEREG(DP_TP_STATUS_A),
1853         DEFINEREG(DP_TP_STATUS_B),
1854         DEFINEREG(DP_TP_STATUS_C),
1855         DEFINEREG(DP_TP_STATUS_D),
1856         DEFINEREG(DP_TP_STATUS_E),
1857
1858         /* DDI buffer control */
1859         DEFINEREG(DDI_BUF_CTL_A),
1860         DEFINEREG(DDI_BUF_CTL_B),
1861         DEFINEREG(DDI_BUF_CTL_C),
1862         DEFINEREG(DDI_BUF_CTL_D),
1863         DEFINEREG(DDI_BUF_CTL_E),
1864
1865         /* Clocks */
1866         DEFINEREG(PIXCLK_GATE),
1867         DEFINEREG(SPLL_CTL),
1868         DEFINEREG(LCPLL_CTL),
1869         DEFINEREG(WRPLL_CTL1),
1870         DEFINEREG(WRPLL_CTL2),
1871
1872         /* DDI port clock control */
1873         DEFINEREG(PORT_CLK_SEL_A),
1874         DEFINEREG(PORT_CLK_SEL_B),
1875         DEFINEREG(PORT_CLK_SEL_C),
1876         DEFINEREG(PORT_CLK_SEL_D),
1877         DEFINEREG(PORT_CLK_SEL_E),
1878
1879         /* Pipe clock control */
1880         DEFINEREG(PIPE_CLK_SEL_A),
1881         DEFINEREG(PIPE_CLK_SEL_B),
1882         DEFINEREG(PIPE_CLK_SEL_C),
1883
1884         /* Pipe line time */
1885         DEFINEREG(PIPE_WM_LINETIME_A),
1886         DEFINEREG(PIPE_WM_LINETIME_B),
1887         DEFINEREG(PIPE_WM_LINETIME_C),
1888
1889         /* Fuses */
1890         DEFINEREG(SFUSE_STRAP),
1891
1892 };
1893
1894 static struct reg_debug i945gm_mi_regs[] = {
1895         DEFINEREG(PGETBL_CTL),
1896         DEFINEREG(PGTBL_ER),
1897         DEFINEREG(EXCC),
1898         DEFINEREG(HWS_PGA),
1899         DEFINEREG(IPEIR),
1900         DEFINEREG(IPEHR),
1901         DEFINEREG(INST_DONE),
1902         DEFINEREG(NOP_ID),
1903         DEFINEREG(HWSTAM),
1904         DEFINEREG(SCPD0),
1905         DEFINEREG(IER),
1906         DEFINEREG(IIR),
1907         DEFINEREG(IMR),
1908         DEFINEREG(ISR),
1909         DEFINEREG(EIR),
1910         DEFINEREG(EMR),
1911         DEFINEREG(ESR),
1912         DEFINEREG(INST_PM),
1913         DEFINEREG(ECOSKPD),
1914 };
1915
1916 static void
1917 _intel_dump_reg(struct reg_debug *reg, uint32_t val)
1918 {
1919         char debug[1024];
1920
1921         if (reg->debug_output != NULL) {
1922                 reg->debug_output(debug, sizeof(debug), reg->reg, val);
1923                 printf("%30.30s: 0x%08x (%s)\n",
1924                        reg->name, val, debug);
1925         } else {
1926                 printf("%30.30s: 0x%08x\n", reg->name, val);
1927         }
1928 }
1929
1930 #define intel_dump_regs(regs) _intel_dump_regs(regs, ARRAY_SIZE(regs))
1931
1932 static void
1933 _intel_dump_regs(struct reg_debug *regs, int count)
1934 {
1935         int i;
1936
1937         for (i = 0; i < count; i++) {
1938                 uint32_t val = INREG(regs[i].reg);
1939
1940                 _intel_dump_reg(&regs[i], val);
1941         }
1942 }
1943
1944 DEBUGSTRING(gen6_rp_control)
1945 {
1946         snprintf(result, len, "%s",
1947                  (val & (1 << 7)) ? "enabled" : "disabled");
1948 }
1949
1950 static struct reg_debug gen6_rp_debug_regs[] = {
1951         DEFINEREG2(GEN6_RP_CONTROL, gen6_rp_control),
1952         DEFINEREG(GEN6_RPNSWREQ),
1953         DEFINEREG(GEN6_RP_DOWN_TIMEOUT),
1954         DEFINEREG(GEN6_RP_INTERRUPT_LIMITS),
1955         DEFINEREG(GEN6_RP_UP_THRESHOLD),
1956         DEFINEREG(GEN6_RP_UP_EI),
1957         DEFINEREG(GEN6_RP_DOWN_EI),
1958         DEFINEREG(GEN6_RP_IDLE_HYSTERSIS),
1959         DEFINEREG(GEN6_RC_STATE),
1960         DEFINEREG(GEN6_RC_CONTROL),
1961         DEFINEREG(GEN6_RC1_WAKE_RATE_LIMIT),
1962         DEFINEREG(GEN6_RC6_WAKE_RATE_LIMIT),
1963         DEFINEREG(GEN6_RC_EVALUATION_INTERVAL),
1964         DEFINEREG(GEN6_RC_IDLE_HYSTERSIS),
1965         DEFINEREG(GEN6_RC_SLEEP),
1966         DEFINEREG(GEN6_RC1e_THRESHOLD),
1967         DEFINEREG(GEN6_RC6_THRESHOLD),
1968         DEFINEREG(GEN6_RC_VIDEO_FREQ),
1969         DEFINEREG(GEN6_PMIER),
1970         DEFINEREG(GEN6_PMIMR),
1971         DEFINEREG(GEN6_PMINTRMSK),
1972 };
1973
1974 #define DECLARE_REGS(d,r)       \
1975         { .description = d, .regs = r, .count = ARRAY_SIZE(r) }
1976 static struct {
1977         const char *description;
1978         struct reg_debug *regs;
1979         int count;
1980 } known_registers[] = {
1981         DECLARE_REGS("Gen5",   ironlake_debug_regs),
1982         DECLARE_REGS("i945GM", i945gm_mi_regs),
1983         DECLARE_REGS("Gen2",   intel_debug_regs),
1984         DECLARE_REGS("Gen6",   gen6_rp_debug_regs),
1985         DECLARE_REGS("Gen7.5", haswell_debug_regs)
1986 };
1987 #undef DECLARE_REGS
1988
1989 static void
1990 dump_reg(struct reg_debug *reg, uint32_t val, const char *prefix)
1991 {
1992         char debug[1024];
1993
1994         if (reg->debug_output != NULL) {
1995                 reg->debug_output(debug, sizeof(debug), reg->reg, val);
1996                 printf("%s: %s (0x%x): 0x%08x (%s)\n",
1997                        prefix, reg->name, reg->reg, val, debug);
1998         } else {
1999                 printf("%s: %s (0x%x): 0x%08x\n",
2000                        prefix, reg->name, reg->reg, val);
2001         }
2002 }
2003
2004 static void
2005 str_to_upper(char *str)
2006 {
2007         while(*str) {
2008                 *str = toupper(*str);
2009                 str++;
2010         }
2011 }
2012
2013 static void
2014 decode_register_name(char *name, uint32_t val)
2015 {
2016         int i, j;
2017
2018         str_to_upper(name);
2019
2020         for (i = 0; i < ARRAY_SIZE(known_registers); i++) {
2021                 struct reg_debug *regs = known_registers[i].regs;
2022
2023                 for (j = 0; j < known_registers[i].count; j++)
2024                         if (strstr(regs[j].name, name))
2025                                 dump_reg(&regs[j], val,
2026                                          known_registers[i].description);
2027         }
2028 }
2029
2030 static void
2031 decode_register_address(int address, uint32_t val)
2032 {
2033         int i, j;
2034
2035         for (i = 0; i < ARRAY_SIZE(known_registers); i++) {
2036                 struct reg_debug *regs = known_registers[i].regs;
2037
2038                 for (j = 0; j < known_registers[i].count; j++)
2039                         if (regs[j].reg == address)
2040                                 dump_reg(&regs[j], val,
2041                                          known_registers[i].description);
2042         }
2043 }
2044
2045 static void
2046 decode_register(char *name, uint32_t val)
2047 {
2048         long int address;
2049         char *end;
2050
2051         address = strtoul(name, &end, 0);
2052
2053         /* found a register address */
2054         if (address && *end == '\0')
2055                 decode_register_address(address, val);
2056         else
2057                 decode_register_name(name, val);
2058 }
2059
2060 static void
2061 intel_dump_other_regs(void)
2062 {
2063         int i;
2064         int fp, dpll;
2065         int disp_pipe;
2066         int n, m1, m2, m, p1, p2;
2067         int ref;
2068         int dot;
2069         int phase;
2070 #if 0
2071         int msr;
2072         int crt;
2073 #endif
2074
2075 #if 0
2076         i830DumpIndexed(pScrn, "SR", 0x3c4, 0x3c5, 0, 7);
2077         msr = INREG8(0x3cc);
2078         printf("%20.20s: 0x%02x\n",
2079                    "MSR", (unsigned int)msr);
2080
2081         i830DumpAR(pScrn);
2082         if (msr & 1)
2083                 crt = 0x3d0;
2084         else
2085                 crt = 0x3b0;
2086         i830DumpIndexed(pScrn, "CR", crt + 4, crt + 5, 0, 0x24);
2087 #endif
2088         for (disp_pipe = 0; disp_pipe <= 1; disp_pipe++) {
2089                 fp = INREG(disp_pipe == 0 ? FPA0 : FPB0);
2090                 dpll = INREG(disp_pipe == 0 ? DPLL_A : DPLL_B);
2091                 if (IS_GEN2(devid)) {
2092                         uint32_t lvds = INREG(LVDS);
2093                         if (devid == PCI_CHIP_I855_GM &&
2094                             (lvds & LVDS_PORT_EN) &&
2095                             (lvds & LVDS_PIPEB_SELECT) == (disp_pipe << 30)) {
2096                                 if ((lvds & LVDS_CLKB_POWER_MASK) ==
2097                                     LVDS_CLKB_POWER_UP)
2098                                         p2 = 7;
2099                                 else
2100                                         p2 = 14;
2101                                 switch ((dpll >> 16) & 0x3f) {
2102                                 case 0x01:
2103                                         p1 = 1;
2104                                         break;
2105                                 case 0x02:
2106                                         p1 = 2;
2107                                         break;
2108                                 case 0x04:
2109                                         p1 = 3;
2110                                         break;
2111                                 case 0x08:
2112                                         p1 = 4;
2113                                         break;
2114                                 case 0x10:
2115                                         p1 = 5;
2116                                         break;
2117                                 case 0x20:
2118                                         p1 = 6;
2119                                         break;
2120                                 default:
2121                                         p1 = 1;
2122                                         printf("LVDS P1 0x%x invalid encoding\n",
2123                                                (dpll >> 16) & 0x3f);
2124                                         break;
2125                                 }
2126                         } else {
2127                                 if (dpll & (1 << 23))
2128                                         p2 = 4;
2129                                 else
2130                                         p2 = 2;
2131                                 if (dpll & PLL_P1_DIVIDE_BY_TWO)
2132                                         p1 = 2;
2133                                 else
2134                                         p1 = ((dpll >> 16) & 0x3f) + 2;
2135                         }
2136
2137                         switch ((dpll >> 13) & 0x3) {
2138                         case 0:
2139                                 ref = 48000;
2140                                 break;
2141                         case 3:
2142                                 ref = 66000;
2143                                 break;
2144                         default:
2145                                 ref = 0;
2146                                 printf("ref out of range\n");
2147                                 break;
2148                         }
2149                 } else {
2150                         uint32_t lvds = INREG(LVDS);
2151                         if ((lvds & LVDS_PORT_EN) &&
2152                             (lvds & LVDS_PIPEB_SELECT) == (disp_pipe << 30)) {
2153                                 if ((lvds & LVDS_CLKB_POWER_MASK) ==
2154                                     LVDS_CLKB_POWER_UP)
2155                                         p2 = 7;
2156                                 else
2157                                         p2 = 14;
2158                         } else {
2159                                 switch ((dpll >> 24) & 0x3) {
2160                                 case 0:
2161                                         p2 = 10;
2162                                         break;
2163                                 case 1:
2164                                         p2 = 5;
2165                                         break;
2166                                 default:
2167                                         p2 = 1;
2168                                         printf("p2 out of range\n");
2169                                         break;
2170                                 }
2171                         }
2172                         if (IS_IGD(devid))
2173                                 i = (dpll >> DPLL_FPA01_P1_POST_DIV_SHIFT_IGD) &
2174                                     0x1ff;
2175                         else
2176                                 i = (dpll >> DPLL_FPA01_P1_POST_DIV_SHIFT) &
2177                                     0xff;
2178                         switch (i) {
2179                         case 1:
2180                                 p1 = 1;
2181                                 break;
2182                         case 2:
2183                                 p1 = 2;
2184                                 break;
2185                         case 4:
2186                                 p1 = 3;
2187                                 break;
2188                         case 8:
2189                                 p1 = 4;
2190                                 break;
2191                         case 16:
2192                                 p1 = 5;
2193                                 break;
2194                         case 32:
2195                                 p1 = 6;
2196                                 break;
2197                         case 64:
2198                                 p1 = 7;
2199                                 break;
2200                         case 128:
2201                                 p1 = 8;
2202                                 break;
2203                         case 256:
2204                                 if (IS_IGD(devid)) {
2205                                         p1 = 9;
2206                                         break;
2207                                 }       /* fallback */
2208                         default:
2209                                 p1 = 1;
2210                                 printf("p1 out of range\n");
2211                                 break;
2212                         }
2213
2214                         switch ((dpll >> 13) & 0x3) {
2215                         case 0:
2216                                 ref = 96000;
2217                                 break;
2218                         case 3:
2219                                 ref = 100000;
2220                                 break;
2221                         default:
2222                                 ref = 0;
2223                                 printf("ref out of range\n");
2224                                 break;
2225                         }
2226                 }
2227                 if (IS_965(devid)) {
2228                         phase = (dpll >> 9) & 0xf;
2229                         switch (phase) {
2230                         case 6:
2231                                 break;
2232                         default:
2233                                 printf("SDVO phase shift %d out of range -- probobly not "
2234                                        "an issue.\n", phase);
2235                                 break;
2236                         }
2237                 }
2238                 switch ((dpll >> 8) & 1) {
2239                 case 0:
2240                         break;
2241                 default:
2242                         printf("fp select out of range\n");
2243                         break;
2244                 }
2245                 m1 = ((fp >> 8) & 0x3f);
2246                 if (IS_IGD(devid)) {
2247                         n = ffs((fp & FP_N_IGD_DIV_MASK) >> FP_N_DIV_SHIFT) - 1;
2248                         m2 = (fp & FP_M2_IGD_DIV_MASK) >> FP_M2_DIV_SHIFT;
2249                         m = m2 + 2;
2250                         dot = (ref * m) / n / (p1 * p2);
2251                 } else {
2252                         n = ((fp >> 16) & 0x3f);
2253                         m2 = ((fp >> 0) & 0x3f);
2254                         //m = 5 * (m1 + 2) + (m2 + 2);
2255                         dot =
2256                             (ref * (5 * (m1 + 2) + (m2 + 2)) / (n + 2)) / (p1 *
2257                                                                            p2);
2258                 }
2259
2260                 printf("pipe %s dot %d n %d m1 %d m2 %d p1 %d p2 %d\n",
2261                        disp_pipe == 0 ? "A" : "B", dot, n, m1, m2, p1, p2);
2262         }
2263 }
2264
2265 static void print_usage(void)
2266 {
2267         printf("Usage: intel_reg_dumper [options] [file]\n"
2268                "       intel_reg_dumper [options] register value\n"
2269                "Options:\n"
2270                "  -d id   when a dump file is used, use 'id' as device id (in "
2271                "hex)\n"
2272                "  -h      prints this help\n");
2273 }
2274
2275 int main(int argc, char** argv)
2276 {
2277         struct pci_device *pci_dev;
2278         int opt, n_args;
2279         char *file = NULL, *reg_name = NULL;
2280         uint32_t reg_val;
2281
2282         while ((opt = getopt(argc, argv, "d:h")) != -1) {
2283                 switch (opt) {
2284                 case 'd':
2285                         devid = strtol(optarg, NULL, 16);
2286                         break;
2287                 case 'h':
2288                         print_usage();
2289                         return 0;
2290                 default:
2291                         print_usage();
2292                         return 1;
2293                 }
2294         }
2295
2296         n_args = argc - optind;
2297         if (n_args == 1) {
2298                 file = argv[optind];
2299         } else if (n_args == 2) {
2300                 reg_name = argv[optind];
2301                 reg_val = strtoul(argv[optind + 1], NULL, 0);
2302         } else if (n_args) {
2303                 print_usage();
2304                 return 1;
2305         }
2306
2307         /* the tool operates in "single" mode, decode a single register given
2308          * on the command line: intel_reg_dumper PCH_PP_CONTROL 0xabcd0002 */
2309         if (reg_name) {
2310                 decode_register(reg_name, reg_val);
2311                 return 0;
2312         }
2313
2314         if (file) {
2315                 intel_map_file(file);
2316                 if (devid) {
2317                         if (IS_GEN5(devid))
2318                                 pch = PCH_IBX;
2319                         else
2320                                 pch = PCH_CPT;
2321                 } else {
2322                         printf("Dumping from file without -d argument. "
2323                                "Assuming Ironlake machine.\n");
2324                         devid = 0x0042;
2325                         pch = PCH_IBX;
2326                 }
2327         } else {
2328                 pci_dev = intel_get_pci_device();
2329                 devid = pci_dev->device_id;
2330
2331                 intel_register_access_init(pci_dev, 1);
2332
2333                 if (HAS_PCH_SPLIT(devid))
2334                         intel_check_pch();
2335         }
2336
2337         if (HAS_PCH_SPLIT(devid)) {
2338                 intel_dump_regs(ironlake_debug_regs);
2339         } else if (IS_945GM(devid)) {
2340                 intel_dump_regs(i945gm_mi_regs);
2341                 intel_dump_regs(intel_debug_regs);
2342                 intel_dump_other_regs();
2343         } else {
2344                 intel_dump_regs(intel_debug_regs);
2345                 intel_dump_other_regs();
2346         }
2347
2348         if (IS_GEN6(devid) || IS_GEN7(devid))
2349                 intel_dump_regs(gen6_rp_debug_regs);
2350
2351         if (IS_HASWELL(devid))
2352                 intel_dump_regs(haswell_debug_regs);
2353
2354
2355         intel_register_access_fini();
2356         return 0;
2357 }