drivers/gpu/rogue/services/server/devices/rgx/rgxdebug.c

   1 /*************************************************************************/ /*!
   2 @File
   3 @Title          Rgx debug information
   4 @Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
   5 @Description    RGX debugging functions
   6 @License        Dual MIT/GPLv2
   7
   8 The contents of this file are subject to the MIT license as set out below.
   9
  10 Permission is hereby granted, free of charge, to any person obtaining a copy
  11 of this software and associated documentation files (the "Software"), to deal
  12 in the Software without restriction, including without limitation the rights
  13 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14 copies of the Software, and to permit persons to whom the Software is
  15 furnished to do so, subject to the following conditions:
  16
  17 The above copyright notice and this permission notice shall be included in
  18 all copies or substantial portions of the Software.
  19
  20 Alternatively, the contents of this file may be used under the terms of
  21 the GNU General Public License Version 2 ("GPL") in which case the provisions
  22 of GPL are applicable instead of those above.
  23
  24 If you wish to allow use of your version of this file only under the terms of
  25 GPL, and not to allow others to use your version of this file under the terms
  26 of the MIT license, indicate your decision by deleting the provisions above
  27 and replace them with the notice and other provisions required by GPL as set
  28 out in the file called "GPL-COPYING" included in this distribution. If you do
  29 not delete the provisions above, a recipient may use your version of this file
  30 under the terms of either the MIT license or GPL.
  31
  32 This License is also included in this distribution in the file called
  33 "MIT-COPYING".
  34
  35 EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
  36 PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  37 BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  38 PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
  39 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  40 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  41 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  42 */ /**************************************************************************/
  43 //#define PVR_DPF_FUNCTION_TRACE_ON 1
  44 #undef PVR_DPF_FUNCTION_TRACE_ON
  45
  46 #include "rgxdefs_km.h"
  47 #include "rgxdevice.h"
  48 #include "rgxmem.h"
  49 #include "allocmem.h"
  50 #include "osfunc.h"
  51
  52 #include "lists.h"
  53
  54 #include "rgxdebug.h"
  55 #include "pvrversion.h"
  56 #include "pvr_debug.h"
  57 #include "srvkm.h"
  58 #include "rgxutils.h"
  59 #include "tlstream.h"
  60 #include "rgxfwutils.h"
  61 #include "pvrsrv.h"
  62
  63 #include "devicemem_pdump.h"
  64
  65 #include "rgx_fwif.h"
  66 #include "pvrsrv.h"
  67
  68 #if defined(PVRSRV_ENABLE_FW_TRACE_DEBUGFS)
  69 #include "rgx_fwif_sf.h"
  70 #include "rgxfw_log_helper.h"
  71 #endif
  72
  73 #include "rgxta3d.h"
  74 #include "rgxcompute.h"
  75 #include "rgxtransfer.h"
  76 #if defined(RGX_FEATURE_RAY_TRACING)
  77 #include "rgxray.h"
  78 #endif
  79
  80
  81 #define RGX_DEBUG_STR_SIZE      (150)
  82
  83 #define RGX_CR_BIF_CAT_BASE0                              (0x1200U)
  84 #define RGX_CR_BIF_CAT_BASE1                              (0x1208U)
  85
  86 #define RGX_CR_BIF_CAT_BASEN(n) \
  87         RGX_CR_BIF_CAT_BASE0 + \
  88         ((RGX_CR_BIF_CAT_BASE1 - RGX_CR_BIF_CAT_BASE0) * n)
  89
  90
  91 #define RGXDBG_BIF_IDS \
  92         X(BIF0)\
  93         X(BIF1)\
  94         X(TEXAS_BIF)
  95
  96 #define RGXDBG_SIDEBAND_TYPES \
  97         X(META)\
  98         X(TLA)\
  99         X(VDMM)\
 100         X(CDM)\
 101         X(IPP)\
 102         X(PM)\
 103         X(TILING)\
 104         X(MCU)\
 105         X(PDS)\
 106         X(PBE)\
 107         X(VDMS)\
 108         X(IPF)\
 109         X(ISP)\
 110         X(TPF)\
 111         X(USCS)\
 112         X(PPP)\
 113         X(VCE)\
 114         X(FBCDC)
 115
 116 typedef enum
 117 {
 118 #define X(NAME) RGXDBG_##NAME,
 119         RGXDBG_BIF_IDS
 120 #undef X
 121 } RGXDBG_BIF_ID;
 122
 123 typedef enum
 124 {
 125 #define X(NAME) RGXDBG_##NAME,
 126         RGXDBG_SIDEBAND_TYPES
 127 #undef X
 128 } RGXDBG_SIDEBAND_TYPE;
 129
 130
 131 IMG_CHAR* pszPowStateName [] = {
 132 #define X(NAME) #NAME,
 133         RGXFWIF_POW_STATES
 134 #undef X
 135 };
 136
 137 IMG_CHAR* pszBIFNames [] = {
 138 #define X(NAME) #NAME,
 139         RGXDBG_BIF_IDS
 140 #undef X
 141 };
 142
 143 extern IMG_UINT32 g_ui32HostSampleIRQCount;
 144
 145
 146 #if !defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
 147 /*!
 148 *******************************************************************************
 149
 150  @Function      _RGXDecodePMPC
 151
 152  @Description
 153
 154  Return the name for the PM managed Page Catalogues
 155
 156  @Input ui32PC   - Page Catalogue number
 157
 158  @Return   IMG_VOID
 159
 160 ******************************************************************************/
 161 static IMG_CHAR* _RGXDecodePMPC(IMG_UINT32 ui32PC)
 162 {
 163         IMG_CHAR* pszPMPC = " (-)";
 164
 165         switch (ui32PC)
 166         {
 167                 case 0x8: pszPMPC = " (PM-VCE0)"; break;
 168                 case 0x9: pszPMPC = " (PM-TE0)"; break;
 169                 case 0xA: pszPMPC = " (PM-ZLS0)"; break;
 170                 case 0xB: pszPMPC = " (PM-ALIST0)"; break;
 171                 case 0xC: pszPMPC = " (PM-VCE1)"; break;
 172                 case 0xD: pszPMPC = " (PM-TE1)"; break;
 173                 case 0xE: pszPMPC = " (PM-ZLS1)"; break;
 174                 case 0xF: pszPMPC = " (PM-ALIST1)"; break;
 175         }
 176
 177         return pszPMPC;
 178 }
 179
 180 /*!
 181 *******************************************************************************
 182
 183  @Function      _RGXDecodeBIFReqTags
 184
 185  @Description
 186
 187  Decode the BIF Tag ID and sideband data fields from BIF_FAULT_BANK_REQ_STATUS regs
 188
 189  @Input eBankID                         - BIF identifier
 190  @Input ui32TagID           - Tag ID value
 191  @Input ui32TagSB           - Tag Sideband data
 192  @Output ppszTagID          - Decoded string from the Tag ID
 193  @Output ppszTagSB          - Decoded string from the Tag SB
 194  @Output pszScratchBuf      - Buffer provided to the function to generate the debug strings
 195  @Input ui32ScratchBufSize  - Size of the provided buffer
 196
 197  @Return   IMG_VOID
 198
 199 ******************************************************************************/
 200 static IMG_VOID _RGXDecodeBIFReqTags(RGXDBG_BIF_ID      eBankID,
 201                                                                          IMG_UINT32             ui32TagID,
 202                                                                          IMG_UINT32             ui32TagSB,
 203                                                                          IMG_CHAR               **ppszTagID,
 204                                                                          IMG_CHAR               **ppszTagSB,
 205                                                                          IMG_CHAR               *pszScratchBuf,
 206                                                                          IMG_UINT32             ui32ScratchBufSize)
 207 {
 208         /* default to unknown */
 209         IMG_CHAR *pszTagID = "-";
 210         IMG_CHAR *pszTagSB = "-";
 211
 212         PVR_ASSERT(ppszTagID != IMG_NULL);
 213         PVR_ASSERT(ppszTagSB != IMG_NULL);
 214
 215         switch (ui32TagID)
 216         {
 217                 case 0x0:
 218                 {
 219                         pszTagID = "MMU";
 220                         switch (ui32TagSB)
 221                         {
 222                                 case 0x0: pszTagSB = "Table"; break;
 223                                 case 0x1: pszTagSB = "Directory"; break;
 224                                 case 0x2: pszTagSB = "Catalogue"; break;
 225                         }
 226                         break;
 227                 }
 228                 case 0x1:
 229                 {
 230                         pszTagID = "TLA";
 231                         switch (ui32TagSB)
 232                         {
 233                                 case 0x0: pszTagSB = "Pixel data"; break;
 234                                 case 0x1: pszTagSB = "Command stream data"; break;
 235                                 case 0x2: pszTagSB = "Fence or flush"; break;
 236                         }
 237                         break;
 238                 }
 239                 case 0x2:
 240                 {
 241                         pszTagID = "HOST";
 242                         break;
 243                 }
 244                 case 0x3:
 245                 {
 246                         pszTagID = "META";
 247                         switch (ui32TagSB)
 248                         {
 249                                 case 0x0: pszTagSB = "DCache - Thread 0"; break;
 250                                 case 0x1: pszTagSB = "ICache - Thread 0"; break;
 251                                 case 0x2: pszTagSB = "JTag - Thread 0"; break;
 252                                 case 0x3: pszTagSB = "Slave bus - Thread 0"; break;
 253                                 case 0x4: pszTagSB = "DCache - Thread "; break;
 254                                 case 0x5: pszTagSB = "ICache - Thread 1"; break;
 255                                 case 0x6: pszTagSB = "JTag - Thread 1"; break;
 256                                 case 0x7: pszTagSB = "Slave bus - Thread 1"; break;
 257                         }
 258                         break;
 259                 }
 260                 case 0x4:
 261                 {
 262                         pszTagID = "USC";
 263                         OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 264                                    "Cache line %d", (ui32TagSB & 0x3f));
 265                         pszTagSB = pszScratchBuf;
 266                         break;
 267                 }
 268                 case 0x5:
 269                 {
 270                         pszTagID = "PBE";
 271                         break;
 272                 }
 273                 case 0x6:
 274                 {
 275                         pszTagID = "ISP";
 276                         switch (ui32TagSB)
 277                         {
 278                                 case 0x00: pszTagSB = "ZLS"; break;
 279                                 case 0x20: pszTagSB = "Occlusion Query"; break;
 280                         }
 281                         break;
 282                 }
 283                 case 0x7:
 284                 {
 285 #if defined(RGX_FEATURE_XT_TOP_INFRASTRUCTURE)
 286                         if (eBankID == RGXDBG_TEXAS_BIF)
 287                         {
 288                                 pszTagID = "IPF";
 289                                 switch (ui32TagSB)
 290                                 {
 291                                         case 0x0: pszTagSB = "CPF"; break;
 292                                         case 0x1: pszTagSB = "DBSC"; break;
 293                                         case 0x2:
 294                                         case 0x4:
 295                                         case 0x6:
 296                                         case 0x8: pszTagSB = "Control Stream"; break;
 297                                         case 0x3:
 298                                         case 0x5:
 299                                         case 0x7:
 300                                         case 0x9: pszTagSB = "Primitive Block"; break;
 301                                 }
 302                         }
 303                         else
 304                         {
 305                                 pszTagID = "IPP";
 306                                 switch (ui32TagSB)
 307                                 {
 308                                         case 0x0: pszTagSB = "Macrotile Header"; break;
 309                                         case 0x1: pszTagSB = "Region Header"; break;
 310                                 }
 311                         }
 312 #else
 313                         pszTagID = "IPF";
 314                         switch (ui32TagSB)
 315                         {
 316                                 case 0x0: pszTagSB = "Macrotile Header"; break;
 317                                 case 0x1: pszTagSB = "Region Header"; break;
 318                                 case 0x2: pszTagSB = "DBSC"; break;
 319                                 case 0x3: pszTagSB = "CPF"; break;
 320                                 case 0x4:
 321                                 case 0x6:
 322                                 case 0x8: pszTagSB = "Control Stream"; break;
 323                                 case 0x5:
 324                                 case 0x7:
 325                                 case 0x9: pszTagSB = "Primitive Block"; break;
 326                         }
 327 #endif
 328                         break;
 329                 }
 330                 case 0x8:
 331                 {
 332                         pszTagID = "CDM";
 333                         switch (ui32TagSB)
 334                         {
 335                                 case 0x0: pszTagSB = "Control Stream"; break;
 336                                 case 0x1: pszTagSB = "Indirect Data"; break;
 337                                 case 0x2: pszTagSB = "Event Write"; break;
 338                                 case 0x3: pszTagSB = "Context State"; break;
 339                         }
 340                         break;
 341                 }
 342                 case 0x9:
 343                 {
 344                         pszTagID = "VDM";
 345                         switch (ui32TagSB)
 346                         {
 347                                 case 0x0: pszTagSB = "Control Stream"; break;
 348                                 case 0x1: pszTagSB = "PPP State"; break;
 349                                 case 0x2: pszTagSB = "Index Data"; break;
 350                                 case 0x4: pszTagSB = "Call Stack"; break;
 351                                 case 0x8: pszTagSB = "Context State"; break;
 352                         }
 353                         break;
 354                 }
 355                 case 0xA:
 356                 {
 357                         pszTagID = "PM";
 358                         switch (ui32TagSB)
 359                         {
 360                                 case 0x0: pszTagSB = "PMA_TAFSTACK"; break;
 361                                 case 0x1: pszTagSB = "PMA_TAMLIST"; break;
 362                                 case 0x2: pszTagSB = "PMA_3DFSTACK"; break;
 363                                 case 0x3: pszTagSB = "PMA_3DMLIST"; break;
 364                                 case 0x4: pszTagSB = "PMA_PMCTX0"; break;
 365                                 case 0x5: pszTagSB = "PMA_PMCTX1"; break;
 366                                 case 0x6: pszTagSB = "PMA_MAVP"; break;
 367                                 case 0x7: pszTagSB = "PMA_UFSTACK"; break;
 368                                 case 0x8: pszTagSB = "PMD_TAFSTACK"; break;
 369                                 case 0x9: pszTagSB = "PMD_TAMLIST"; break;
 370                                 case 0xA: pszTagSB = "PMD_3DFSTACK"; break;
 371                                 case 0xB: pszTagSB = "PMD_3DMLIST"; break;
 372                                 case 0xC: pszTagSB = "PMD_PMCTX0"; break;
 373                                 case 0xD: pszTagSB = "PMD_PMCTX1"; break;
 374                                 case 0xF: pszTagSB = "PMD_UFSTACK"; break;
 375                                 case 0x10: pszTagSB = "PMA_TAMMUSTACK"; break;
 376                                 case 0x11: pszTagSB = "PMA_3DMMUSTACK"; break;
 377                                 case 0x12: pszTagSB = "PMD_TAMMUSTACK"; break;
 378                                 case 0x13: pszTagSB = "PMD_3DMMUSTACK"; break;
 379                                 case 0x14: pszTagSB = "PMA_TAUFSTACK"; break;
 380                                 case 0x15: pszTagSB = "PMA_3DUFSTACK"; break;
 381                                 case 0x16: pszTagSB = "PMD_TAUFSTACK"; break;
 382                                 case 0x17: pszTagSB = "PMD_3DUFSTACK"; break;
 383                                 case 0x18: pszTagSB = "PMA_TAVFP"; break;
 384                                 case 0x19: pszTagSB = "PMD_3DVFP"; break;
 385                                 case 0x1A: pszTagSB = "PMD_TAVFP"; break;
 386                         }
 387                         break;
 388                 }
 389                 case 0xB:
 390                 {
 391                         pszTagID = "TA";
 392                         switch (ui32TagSB)
 393                         {
 394                                 case 0x1: pszTagSB = "VCE"; break;
 395                                 case 0x2: pszTagSB = "TPC"; break;
 396                                 case 0x3: pszTagSB = "TE Control Stream"; break;
 397                                 case 0x4: pszTagSB = "TE Region Header"; break;
 398                                 case 0x5: pszTagSB = "TE Render Target Cache"; break;
 399                                 case 0x6: pszTagSB = "TEAC Render Target Cache"; break;
 400                                 case 0x7: pszTagSB = "VCE Render Target Cache"; break;
 401                                 case 0x8: pszTagSB = "PPP Context State"; break;
 402                         }
 403                         break;
 404                 }
 405                 case 0xC:
 406                 {
 407                         pszTagID = "TPF";
 408                         switch (ui32TagSB)
 409                         {
 410                                 case 0x0: pszTagSB = "TPF0: Primitive Block"; break;
 411                                 case 0x1: pszTagSB = "TPF0: Depth Bias"; break;
 412                                 case 0x2: pszTagSB = "TPF0: Per Primitive IDs"; break;
 413                                 case 0x3: pszTagSB = "CPF - Tables"; break;
 414                                 case 0x4: pszTagSB = "TPF1: Primitive Block"; break;
 415                                 case 0x5: pszTagSB = "TPF1: Depth Bias"; break;
 416                                 case 0x6: pszTagSB = "TPF1: Per Primitive IDs"; break;
 417                                 case 0x7: pszTagSB = "CPF - Data: Pipe 0"; break;
 418                                 case 0x8: pszTagSB = "TPF2: Primitive Block"; break;
 419                                 case 0x9: pszTagSB = "TPF2: Depth Bias"; break;
 420                                 case 0xA: pszTagSB = "TPF2: Per Primitive IDs"; break;
 421                                 case 0xB: pszTagSB = "CPF - Data: Pipe 1"; break;
 422                                 case 0xC: pszTagSB = "TPF3: Primitive Block"; break;
 423                                 case 0xD: pszTagSB = "TPF3: Depth Bias"; break;
 424                                 case 0xE: pszTagSB = "TPF3: Per Primitive IDs"; break;
 425                                 case 0xF: pszTagSB = "CPF - Data: Pipe 2"; break;
 426                         }
 427                         break;
 428                 }
 429                 case 0xD:
 430                 {
 431                         pszTagID = "PDS";
 432                         break;
 433                 }
 434                 case 0xE:
 435                 {
 436                         pszTagID = "MCU";
 437                         {
 438                                 IMG_UINT32 ui32Burst = (ui32TagSB >> 5) & 0x7;
 439                                 IMG_UINT32 ui32GroupEnc = (ui32TagSB >> 2) & 0x7;
 440                                 IMG_UINT32 ui32Group = ui32TagSB & 0x3;
 441
 442                                 IMG_CHAR* pszBurst = "";
 443                                 IMG_CHAR* pszGroupEnc = "";
 444                                 IMG_CHAR* pszGroup = "";
 445
 446                                 switch (ui32Burst)
 447                                 {
 448                                         case 0x0:
 449                                         case 0x1: pszBurst = "128bit word within the Lower 256bits"; break;
 450                                         case 0x2:
 451                                         case 0x3: pszBurst = "128bit word within the Upper 256bits"; break;
 452                                         case 0x4: pszBurst = "Lower 256bits"; break;
 453                                         case 0x5: pszBurst = "Upper 256bits"; break;
 454                                         case 0x6: pszBurst = "512 bits"; break;
 455                                 }
 456                                 switch (ui32GroupEnc)
 457                                 {
 458 #if defined(RGX_FEATURE_XT_TOP_INFRASTRUCTURE)
 459                                         case 0x0: pszGroupEnc = "PDS_REQ"; break;
 460                                         case 0x1: pszGroupEnc = "USC_REQ"; break;
 461                                         case 0x2: pszGroupEnc = "MADD_REQ"; break;
 462                                         case 0x3: pszGroupEnc = "USCB_USC"; break;
 463 #else
 464                                         case 0x0: pszGroupEnc = "TPUA_USC"; break;
 465                                         case 0x1: pszGroupEnc = "TPUB_USC"; break;
 466                                         case 0x2: pszGroupEnc = "USCA_USC"; break;
 467                                         case 0x3: pszGroupEnc = "USCB_USC"; break;
 468                                         case 0x4: pszGroupEnc = "PDS_USC"; break;
 469 #if (RGX_FEATURE_NUM_CLUSTERS < 6)
 470                                         case 0x5: pszGroupEnc = "PDSRW"; break;
 471 #elif (RGX_FEATURE_NUM_CLUSTERS == 6)
 472                                         case 0x5: pszGroupEnc = "UPUC_USC"; break;
 473                                         case 0x6: pszGroupEnc = "TPUC_USC"; break;
 474                                         case 0x7: pszGroupEnc = "PDSRW"; break;
 475 #endif
 476 #endif
 477                                 }
 478                                 switch (ui32Group)
 479                                 {
 480                                         case 0x0: pszGroup = "Banks 0-3"; break;
 481                                         case 0x1: pszGroup = "Banks 4-7"; break;
 482                                         case 0x2: pszGroup = "Banks 8-11"; break;
 483                                         case 0x3: pszGroup = "Banks 12-15"; break;
 484                                 }
 485
 486                                 OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 487                                                                 "%s, %s, %s", pszBurst, pszGroupEnc, pszGroup);
 488                                 pszTagSB = pszScratchBuf;
 489                         }
 490                         break;
 491                 }
 492                 case 0xF:
 493                 {
 494                         pszTagID = "FB_CDC";
 495 #if defined(RGX_FEATURE_XT_TOP_INFRASTRUCTURE)
 496                         {
 497                                 IMG_UINT32 ui32Req   = (ui32TagSB >> 0) & 0xf;
 498                                 IMG_UINT32 ui32MCUSB = (ui32TagSB >> 4) & 0x3;
 499                                 IMG_CHAR* pszReqOrig = "";
 500
 501                                 switch (ui32Req)
 502                                 {
 503                                         case 0x0: pszReqOrig = "FBC Request, originator ZLS"; break;
 504                                         case 0x1: pszReqOrig = "FBC Request, originator PBE"; break;
 505                                         case 0x2: pszReqOrig = "FBC Request, originator Host"; break;
 506                                         case 0x3: pszReqOrig = "FBC Request, originator TLA"; break;
 507                                         case 0x4: pszReqOrig = "FBDC Request, originator ZLS"; break;
 508                                         case 0x5: pszReqOrig = "FBDC Request, originator MCU"; break;
 509                                         case 0x6: pszReqOrig = "FBDC Request, originator Host"; break;
 510                                         case 0x7: pszReqOrig = "FBDC Request, originator TLA"; break;
 511                                         case 0x8: pszReqOrig = "FBC Request, originator ZLS Requester Fence"; break;
 512                                         case 0x9: pszReqOrig = "FBC Request, originator PBE Requester Fence"; break;
 513                                         case 0xa: pszReqOrig = "FBC Request, originator Host Requester Fence"; break;
 514                                         case 0xb: pszReqOrig = "FBC Request, originator TLA Requester Fence"; break;
 515                                         case 0xc: pszReqOrig = "Reserved"; break;
 516                                         case 0xd: pszReqOrig = "Reserved"; break;
 517                                         case 0xe: pszReqOrig = "FBDC Request, originator FBCDC(Host) Memory Fence"; break;
 518                                         case 0xf: pszReqOrig = "FBDC Request, originator FBCDC(TLA) Memory Fence"; break;
 519                                 }
 520                                 OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 521                                            "%s, MCU sideband 0x%X", pszReqOrig, ui32MCUSB);
 522                                 pszTagSB = pszScratchBuf;
 523                         }
 524 #else
 525                         {
 526                                 IMG_UINT32 ui32Req   = (ui32TagSB >> 2) & 0x7;
 527                                 IMG_UINT32 ui32MCUSB = (ui32TagSB >> 0) & 0x3;
 528                                 IMG_CHAR* pszReqOrig = "";
 529
 530                                 switch (ui32Req)
 531                                 {
 532                                         case 0x0: pszReqOrig = "FBC Request, originator ZLS";   break;
 533                                         case 0x1: pszReqOrig = "FBC Request, originator PBE";   break;
 534                                         case 0x2: pszReqOrig = "FBC Request, originator Host";  break;
 535                                         case 0x3: pszReqOrig = "FBC Request, originator TLA";   break;
 536                                         case 0x4: pszReqOrig = "FBDC Request, originator ZLS";  break;
 537                                         case 0x5: pszReqOrig = "FBDC Request, originator MCU";  break;
 538                                         case 0x6: pszReqOrig = "FBDC Request, originator Host"; break;
 539                                         case 0x7: pszReqOrig = "FBDC Request, originator TLA";  break;
 540                                 }
 541                                 OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 542                                            "%s, MCU sideband 0x%X", pszReqOrig, ui32MCUSB);
 543                                 pszTagSB = pszScratchBuf;
 544                         }
 545 #endif
 546                         break;
 547                 }
 548         } /* switch(TagID) */
 549
 550         *ppszTagID = pszTagID;
 551         *ppszTagSB = pszTagSB;
 552 }
 553 #endif
 554
 555
 556 #if defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
 557 /*!
 558 *******************************************************************************
 559
 560  @Function      _RGXDecodeMMULevel
 561
 562  @Description
 563
 564  Return the name for the MMU level that faulted.
 565
 566  @Input ui32MMULevel     - MMU level
 567
 568  @Return   IMG_CHAR* to the sting describing the MMU level that faulted.
 569
 570 ******************************************************************************/
 571 static IMG_CHAR* _RGXDecodeMMULevel(IMG_UINT32 ui32MMULevel)
 572 {
 573         IMG_CHAR* pszMMULevel = "";
 574
 575         switch (ui32MMULevel)
 576         {
 577                 case 0x0: pszMMULevel = " (Page Table)"; break;
 578                 case 0x1: pszMMULevel = " (Page Directory)"; break;
 579                 case 0x2: pszMMULevel = " (Page Catalog)"; break;
 580                 case 0x3: pszMMULevel = " (Cat Base)"; break;
 581         }
 582
 583         return pszMMULevel;
 584 }
 585
 586
 587 /*!
 588 *******************************************************************************
 589
 590  @Function      _RGXDecodeMMUReqTags
 591
 592  @Description
 593
 594  Decodes the MMU Tag ID and Sideband data fields from RGX_CR_MMU_FAULT_META_STATUS and
 595  RGX_CR_MMU_FAULT_STATUS regs.
 596
 597  @Input ui32TagID           - Tag ID value
 598  @Input ui32TagSB           - Tag Sideband data
 599  @Output ppszTagID          - Decoded string from the Tag ID
 600  @Output ppszTagSB          - Decoded string from the Tag SB
 601  @Output pszScratchBuf      - Buffer provided to the function to generate the debug strings
 602  @Input ui32ScratchBufSize  - Size of the provided buffer
 603
 604  @Return   IMG_VOID
 605
 606 ******************************************************************************/
 607 static IMG_VOID _RGXDecodeMMUReqTags(IMG_UINT32  ui32TagID,
 608                                                                          IMG_UINT32  ui32TagSB,
 609                                      IMG_CHAR    **ppszTagID,
 610                                                                          IMG_CHAR    **ppszTagSB,
 611                                                                          IMG_CHAR    *pszScratchBuf,
 612                                                                          IMG_UINT32  ui32ScratchBufSize)
 613 {
 614         IMG_INT32  i32SideBandType = -1;
 615         IMG_CHAR   *pszTagID = "-";
 616         IMG_CHAR   *pszTagSB = "-";
 617
 618         PVR_ASSERT(ppszTagID != IMG_NULL);
 619         PVR_ASSERT(ppszTagSB != IMG_NULL);
 620
 621         switch (ui32TagID)
 622         {
 623                 case  0: pszTagID = "META (Jones)"; i32SideBandType = RGXDBG_META; break;
 624                 case  1: pszTagID = "TLA (Jones)"; i32SideBandType = RGXDBG_TLA; break;
 625                 case  3: pszTagID = "VDMM (Jones)"; i32SideBandType = RGXDBG_VDMM; break;
 626                 case  4: pszTagID = "CDM (Jones)"; i32SideBandType = RGXDBG_CDM; break;
 627                 case  5: pszTagID = "IPP (Jones)"; i32SideBandType = RGXDBG_IPP; break;
 628                 case  6: pszTagID = "PM (Jones)"; i32SideBandType = RGXDBG_PM; break;
 629                 case  7: pszTagID = "Tiling (Jones)"; i32SideBandType = RGXDBG_TILING; break;
 630                 case  8: pszTagID = "MCU (Texas 0)"; i32SideBandType = RGXDBG_MCU; break;
 631                 case  9: pszTagID = "PDS (Texas 0)"; i32SideBandType = RGXDBG_PDS; break;
 632                 case 10: pszTagID = "PBE0 (Texas 0)"; i32SideBandType = RGXDBG_PBE; break;
 633                 case 11: pszTagID = "PBE1 (Texas 0)"; i32SideBandType = RGXDBG_PBE; break;
 634                 case 12: pszTagID = "VDMS (Black Pearl 0)"; i32SideBandType = RGXDBG_VDMS; break;
 635                 case 13: pszTagID = "IPF (Black Pearl 0)"; i32SideBandType = RGXDBG_IPF; break;
 636                 case 14: pszTagID = "ISP (Black Pearl 0)"; i32SideBandType = RGXDBG_ISP; break;
 637                 case 15: pszTagID = "TPF (Black Pearl 0)"; i32SideBandType = RGXDBG_TPF; break;
 638                 case 16: pszTagID = "USCS (Black Pearl 0)"; i32SideBandType = RGXDBG_USCS; break;
 639                 case 17: pszTagID = "PPP (Black Pearl 0)"; i32SideBandType = RGXDBG_PPP; break;
 640                 case 18: pszTagID = "VCE (Black Pearl 0)"; i32SideBandType = RGXDBG_VCE; break;
 641                 case 19: pszTagID = "FBCDC (Black Pearl 0)"; i32SideBandType = RGXDBG_FBCDC; break;
 642                 case 20: pszTagID = "MCU (Texas 1)"; i32SideBandType = RGXDBG_MCU; break;
 643                 case 21: pszTagID = "PDS (Texas 1)"; i32SideBandType = RGXDBG_PDS; break;
 644                 case 22: pszTagID = "PBE0 (Texas 1)"; i32SideBandType = RGXDBG_PBE; break;
 645                 case 23: pszTagID = "PBE1 (Texas 1)"; i32SideBandType = RGXDBG_PBE; break;
 646                 case 24: pszTagID = "MCU (Texas 2)"; i32SideBandType = RGXDBG_MCU; break;
 647                 case 25: pszTagID = "PDS (Texas 2)"; i32SideBandType = RGXDBG_PDS; break;
 648                 case 26: pszTagID = "PBE0 (Texas 2)"; i32SideBandType = RGXDBG_PBE; break;
 649                 case 27: pszTagID = "PBE1 (Texas 2)"; i32SideBandType = RGXDBG_PBE; break;
 650                 case 28: pszTagID = "VDMS (Black Pearl 1)"; i32SideBandType = RGXDBG_VDMS; break;
 651                 case 29: pszTagID = "IPF (Black Pearl 1)"; i32SideBandType = RGXDBG_IPF; break;
 652                 case 30: pszTagID = "ISP (Black Pearl 1)"; i32SideBandType = RGXDBG_ISP; break;
 653                 case 31: pszTagID = "TPF (Black Pearl 1)"; i32SideBandType = RGXDBG_TPF; break;
 654                 case 32: pszTagID = "USCS (Black Pearl 1)"; i32SideBandType = RGXDBG_USCS; break;
 655                 case 33: pszTagID = "PPP (Black Pearl 1)"; i32SideBandType = RGXDBG_PPP; break;
 656                 case 34: pszTagID = "VCE (Black Pearl 1)"; i32SideBandType = RGXDBG_VCE; break;
 657                 case 35: pszTagID = "FBCDC (Black Pearl 1)"; i32SideBandType = RGXDBG_FBCDC; break;
 658                 case 36: pszTagID = "MCU (Texas 3)"; i32SideBandType = RGXDBG_MCU; break;
 659                 case 37: pszTagID = "PDS (Texas 3)"; i32SideBandType = RGXDBG_PDS; break;
 660                 case 38: pszTagID = "PBE0 (Texas 3)"; i32SideBandType = RGXDBG_PBE; break;
 661                 case 39: pszTagID = "PBE1 (Texas 3)"; i32SideBandType = RGXDBG_PBE; break;
 662         }
 663
 664         switch (i32SideBandType)
 665         {
 666                 case RGXDBG_META:
 667                 {
 668                         switch (ui32TagSB)
 669                         {
 670                                 case 0x0: pszTagSB = "DCache - Thread 0"; break;
 671                                 case 0x1: pszTagSB = "ICache - Thread 0"; break;
 672                                 case 0x2: pszTagSB = "JTag - Thread 0"; break;
 673                                 case 0x3: pszTagSB = "Slave bus - Thread 0"; break;
 674                                 case 0x4: pszTagSB = "DCache - Thread 1"; break;
 675                                 case 0x5: pszTagSB = "ICache - Thread 1"; break;
 676                                 case 0x6: pszTagSB = "JTag - Thread 1"; break;
 677                                 case 0x7: pszTagSB = "Slave bus - Thread 1"; break;
 678                         }
 679                         break;
 680                 }
 681
 682                 case RGXDBG_TLA:
 683                 {
 684                         switch (ui32TagSB)
 685                         {
 686                                 case 0x0: pszTagSB = "Pixel data"; break;
 687                                 case 0x1: pszTagSB = "Command stream data"; break;
 688                                 case 0x2: pszTagSB = "Fence or flush"; break;
 689                         }
 690                         break;
 691                 }
 692
 693                 case RGXDBG_VDMM:
 694                 {
 695                         switch (ui32TagSB)
 696                         {
 697                                 case 0x0: pszTagSB = "Control Stream - Read Only"; break;
 698                                 case 0x1: pszTagSB = "PPP State - Read Only"; break;
 699                                 case 0x2: pszTagSB = "Indices - Read Only"; break;
 700                                 case 0x4: pszTagSB = "Call Stack - Read/Write"; break;
 701                                 case 0x6: pszTagSB = "DrawIndirect - Read Only"; break;
 702                                 case 0xA: pszTagSB = "Context State - Write Only"; break;
 703                         }
 704                         break;
 705                 }
 706
 707                 case RGXDBG_CDM:
 708                 {
 709                         switch (ui32TagSB)
 710                         {
 711                                 case 0x0: pszTagSB = "Control Stream"; break;
 712                                 case 0x1: pszTagSB = "Indirect Data"; break;
 713                                 case 0x2: pszTagSB = "Event Write"; break;
 714                                 case 0x3: pszTagSB = "Context State"; break;
 715                         }
 716                         break;
 717                 }
 718
 719                 case RGXDBG_IPP:
 720                 {
 721                         switch (ui32TagSB)
 722                         {
 723                                 case 0x0: pszTagSB = "Macrotile Header"; break;
 724                                 case 0x1: pszTagSB = "Region Header"; break;
 725                         }
 726                         break;
 727                 }
 728
 729                 case RGXDBG_PM:
 730                 {
 731                         switch (ui32TagSB)
 732                         {
 733                                 case 0x0: pszTagSB = "PMA_TAFSTACK"; break;
 734                                 case 0x1: pszTagSB = "PMA_TAMLIST"; break;
 735                                 case 0x2: pszTagSB = "PMA_3DFSTACK"; break;
 736                                 case 0x3: pszTagSB = "PMA_3DMLIST"; break;
 737                                 case 0x4: pszTagSB = "PMA_PMCTX0"; break;
 738                                 case 0x5: pszTagSB = "PMA_PMCTX1"; break;
 739                                 case 0x6: pszTagSB = "PMA_MAVP"; break;
 740                                 case 0x7: pszTagSB = "PMA_UFSTACK"; break;
 741                                 case 0x8: pszTagSB = "PMD_TAFSTACK"; break;
 742                                 case 0x9: pszTagSB = "PMD_TAMLIST"; break;
 743                                 case 0xA: pszTagSB = "PMD_3DFSTACK"; break;
 744                                 case 0xB: pszTagSB = "PMD_3DMLIST"; break;
 745                                 case 0xC: pszTagSB = "PMD_PMCTX0"; break;
 746                                 case 0xD: pszTagSB = "PMD_PMCTX1"; break;
 747                                 case 0xF: pszTagSB = "PMD_UFSTACK"; break;
 748                                 case 0x10: pszTagSB = "PMA_TAMMUSTACK"; break;
 749                                 case 0x11: pszTagSB = "PMA_3DMMUSTACK"; break;
 750                                 case 0x12: pszTagSB = "PMD_TAMMUSTACK"; break;
 751                                 case 0x13: pszTagSB = "PMD_3DMMUSTACK"; break;
 752                                 case 0x14: pszTagSB = "PMA_TAUFSTACK"; break;
 753                                 case 0x15: pszTagSB = "PMA_3DUFSTACK"; break;
 754                                 case 0x16: pszTagSB = "PMD_TAUFSTACK"; break;
 755                                 case 0x17: pszTagSB = "PMD_3DUFSTACK"; break;
 756                                 case 0x18: pszTagSB = "PMA_TAVFP"; break;
 757                                 case 0x19: pszTagSB = "PMD_3DVFP"; break;
 758                                 case 0x1A: pszTagSB = "PMD_TAVFP"; break;
 759                         }
 760                         break;
 761                 }
 762
 763                 case RGXDBG_TILING:
 764                 {
 765                         switch (ui32TagSB)
 766                         {
 767                                 case 0x0: pszTagSB = "PSG Control Stream TP0"; break;
 768                                 case 0x1: pszTagSB = "TPC TP0"; break;
 769                                 case 0x2: pszTagSB = "VCE0"; break;
 770                                 case 0x3: pszTagSB = "VCE1"; break;
 771                                 case 0x4: pszTagSB = "PSG Control Stream TP1"; break;
 772                                 case 0x5: pszTagSB = "TPC TP1"; break;
 773                                 case 0x8: pszTagSB = "PSG Region Header TP0"; break;
 774                                 case 0xC: pszTagSB = "PSG Region Header TP1"; break;
 775                         }
 776                         break;
 777                 }
 778
 779                 case RGXDBG_VDMS:
 780                 {
 781                         switch (ui32TagSB)
 782                         {
 783                                 case 0x0: pszTagSB = "Context State - Write Only"; break;
 784                         }
 785                         break;
 786                 }
 787
 788                 case RGXDBG_IPF:
 789                 {
 790                         switch (ui32TagSB)
 791                         {
 792                                 case 0x00:
 793                                 case 0x20: pszTagSB = "CPF"; break;
 794                                 case 0x01: pszTagSB = "DBSC"; break;
 795                                 case 0x02:
 796                                 case 0x04:
 797                                 case 0x06:
 798                                 case 0x08:
 799                                 case 0x0A:
 800                                 case 0x0C:
 801                                 case 0x0E:
 802                                 case 0x10: pszTagSB = "Control Stream"; break;
 803                                 case 0x03:
 804                                 case 0x05:
 805                                 case 0x07:
 806                                 case 0x09:
 807                                 case 0x0B:
 808                                 case 0x0D:
 809                                 case 0x0F:
 810                                 case 0x11: pszTagSB = "Primitive Block"; break;
 811                         }
 812                         break;
 813                 }
 814
 815                 case RGXDBG_ISP:
 816                 {
 817                         switch (ui32TagSB)
 818                         {
 819                                 case 0x00: pszTagSB = "ZLS read/write"; break;
 820                                 case 0x20: pszTagSB = "Occlusion query read/write"; break;
 821                         }
 822                         break;
 823                 }
 824
 825                 case RGXDBG_TPF:
 826                 {
 827                         switch (ui32TagSB)
 828                         {
 829                                 case 0x0: pszTagSB = "TPF0: Primitive Block"; break;
 830                                 case 0x1: pszTagSB = "TPF0: Depth Bias"; break;
 831                                 case 0x2: pszTagSB = "TPF0: Per Primitive IDs"; break;
 832                                 case 0x3: pszTagSB = "CPF - Tables"; break;
 833                                 case 0x4: pszTagSB = "TPF1: Primitive Block"; break;
 834                                 case 0x5: pszTagSB = "TPF1: Depth Bias"; break;
 835                                 case 0x6: pszTagSB = "TPF1: Per Primitive IDs"; break;
 836                                 case 0x7: pszTagSB = "CPF - Data: Pipe 0"; break;
 837                                 case 0x8: pszTagSB = "TPF2: Primitive Block"; break;
 838                                 case 0x9: pszTagSB = "TPF2: Depth Bias"; break;
 839                                 case 0xA: pszTagSB = "TPF2: Per Primitive IDs"; break;
 840                                 case 0xB: pszTagSB = "CPF - Data: Pipe 1"; break;
 841                                 case 0xC: pszTagSB = "TPF3: Primitive Block"; break;
 842                                 case 0xD: pszTagSB = "TPF3: Depth Bias"; break;
 843                                 case 0xE: pszTagSB = "TPF3: Per Primitive IDs"; break;
 844                                 case 0xF: pszTagSB = "CPF - Data: Pipe 2"; break;
 845                         }
 846                         break;
 847                 }
 848
 849                 case RGXDBG_FBCDC:
 850                 {
 851                         IMG_UINT32 ui32Req   = (ui32TagSB >> 0) & 0xf;
 852                         IMG_UINT32 ui32MCUSB = (ui32TagSB >> 4) & 0x3;
 853                         IMG_CHAR* pszReqOrig = "";
 854
 855                         switch (ui32Req)
 856                         {
 857                                 case 0x0: pszReqOrig = "FBC Request, originator ZLS";  break;
 858                                 case 0x1: pszReqOrig = "FBC Request, originator PBE"; break;
 859                                 case 0x2: pszReqOrig = "FBC Request, originator Host"; break;
 860                                 case 0x3: pszReqOrig = "FBC Request, originator TLA"; break;
 861                                 case 0x4: pszReqOrig = "FBDC Request, originator ZLS"; break;
 862                                 case 0x5: pszReqOrig = "FBDC Request, originator MCU"; break;
 863                                 case 0x6: pszReqOrig = "FBDC Request, originator Host"; break;
 864                                 case 0x7: pszReqOrig = "FBDC Request, originator TLA"; break;
 865                                 case 0x8: pszReqOrig = "FBC Request, originator ZLS Requester Fence"; break;
 866                                 case 0x9: pszReqOrig = "FBC Request, originator PBE Requester Fence"; break;
 867                                 case 0xa: pszReqOrig = "FBC Request, originator Host Requester Fence"; break;
 868                                 case 0xb: pszReqOrig = "FBC Request, originator TLA Requester Fence"; break;
 869                                 case 0xc: pszReqOrig = "Reserved"; break;
 870                                 case 0xd: pszReqOrig = "Reserved"; break;
 871                                 case 0xe: pszReqOrig = "FBDC Request, originator FBCDC(Host) Memory Fence"; break;
 872                                 case 0xf: pszReqOrig = "FBDC Request, originator FBCDC(TLA) Memory Fence"; break;
 873                         }
 874                         OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 875                                    "%s, MCU sideband 0x%X", pszReqOrig, ui32MCUSB);
 876                         pszTagSB = pszScratchBuf;
 877                         break;
 878                 }
 879
 880                 case RGXDBG_MCU:
 881                 {
 882                         IMG_UINT32 ui32SetNumber = (ui32TagSB >> 5) & 0x7;
 883                         IMG_UINT32 ui32WayNumber = (ui32TagSB >> 2) & 0x7;
 884                         IMG_UINT32 ui32Group     = ui32TagSB & 0x3;
 885
 886                         IMG_CHAR* pszGroup = "";
 887
 888                         switch (ui32Group)
 889                         {
 890                                 case 0x0: pszGroup = "Banks 0-1"; break;
 891                                 case 0x1: pszGroup = "Banks 2-3"; break;
 892                                 case 0x2: pszGroup = "Banks 4-5"; break;
 893                                 case 0x3: pszGroup = "Banks 6-7"; break;
 894                         }
 895
 896                         OSSNPrintf(pszScratchBuf, ui32ScratchBufSize,
 897                                    "Set=%d, Way=%d, %s", ui32SetNumber, ui32WayNumber, pszGroup);
 898                         pszTagSB = pszScratchBuf;
 899                         break;
 900                 }
 901
 902                 default:
 903                 {
 904                         OSSNPrintf(pszScratchBuf, ui32ScratchBufSize, "SB=0x%02x", ui32TagSB);
 905                         pszTagSB = pszScratchBuf;
 906                         break;
 907                 }
 908         }
 909
 910         *ppszTagID = pszTagID;
 911         *ppszTagSB = pszTagSB;
 912 }
 913 #endif
 914
 915
 916 #if !defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
 917 /*!
 918 *******************************************************************************
 919
 920  @Function      _RGXDumpRGXBIFBank
 921
 922  @Description
 923
 924  Dump BIF Bank state in human readable form.
 925
 926  @Input psDevInfo                               - RGX device info
 927  @Input eBankID                                 - BIF identifier
 928  @Input ui64MMUStatus                   - MMU Status register value
 929  @Input ui64ReqStatus                   - BIF request Status register value
 930  @Input bBIFSummary                             - Flag to check whether the function is called
 931                                                                   as a part of the debug dump summary or
 932                                                                   as a part of a HWR log
 933  @Return   IMG_VOID
 934
 935 ******************************************************************************/
 936 static IMG_VOID _RGXDumpRGXBIFBank(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
 937                                    PVRSRV_RGXDEV_INFO   *psDevInfo,
 938                                    RGXDBG_BIF_ID                eBankID,
 939                                    IMG_UINT64                   ui64MMUStatus,
 940                                    IMG_UINT64                   ui64ReqStatus,
 941                                    IMG_BOOL                             bBIFSummary)
 942 {
 943
 944         if (ui64MMUStatus == 0x0)
 945         {
 946                 PVR_DUMPDEBUG_LOG(("%s - OK", pszBIFNames[eBankID]));
 947         }
 948         else
 949         {
 950                 /* Bank 0 & 1 share the same fields */
 951                 PVR_DUMPDEBUG_LOG(("%s%s - FAULT:",
 952                                                   (bBIFSummary)?"":"    ",
 953                                                   pszBIFNames[eBankID]));
 954
 955                 /* MMU Status */
 956                 {
 957                         IMG_UINT32 ui32PC =
 958                                 (ui64MMUStatus & ~RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_CLRMSK) >>
 959                                         RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_SHIFT;
 960
 961                         IMG_UINT32 ui32PageSize =
 962                                 (ui64MMUStatus & ~RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_PAGE_SIZE_CLRMSK) >>
 963                                         RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_PAGE_SIZE_SHIFT;
 964
 965                         IMG_UINT32 ui32MMUDataType =
 966                                 (ui64MMUStatus & ~RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_DATA_TYPE_CLRMSK) >>
 967                                         RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_DATA_TYPE_SHIFT;
 968
 969                         IMG_BOOL bROFault = (ui64MMUStatus & RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_FAULT_RO_EN) != 0;
 970                         IMG_BOOL bProtFault = (ui64MMUStatus & RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_FAULT_PM_META_RO_EN) != 0;
 971
 972                         PVR_DUMPDEBUG_LOG(("%s  * MMU status (0x%016llX): PC = %d%s, Page Size = %d, MMU data type = %d%s%s.",
 973                                           (bBIFSummary)?"":"    ",
 974                                                           ui64MMUStatus,
 975                                           ui32PC,
 976                                           (ui32PC < 0x8)?"":_RGXDecodePMPC(ui32PC),
 977                                           ui32PageSize,
 978                                           ui32MMUDataType,
 979                                           (bROFault)?", Read Only fault":"",
 980                                           (bProtFault)?", PM/META protection fault":""));
 981                 }
 982
 983                 /* Req Status */
 984                 {
 985                         IMG_CHAR *pszTagID;
 986                         IMG_CHAR *pszTagSB;
 987                         IMG_CHAR aszScratch[RGX_DEBUG_STR_SIZE];
 988
 989                         IMG_BOOL bRead = (ui64ReqStatus & RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_RNW_EN) != 0;
 990                         IMG_UINT32 ui32TagSB =
 991                                 (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_SB_CLRMSK) >>
 992                                         RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_SB_SHIFT;
 993                         IMG_UINT32 ui32TagID =
 994                                 (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_ID_CLRMSK) >>
 995                                                         RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_ID_SHIFT;
 996                         IMG_UINT64 ui64Addr = (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK);
 997
 998                         _RGXDecodeBIFReqTags(eBankID, ui32TagID, ui32TagSB, &pszTagID, &pszTagSB, &aszScratch[0], RGX_DEBUG_STR_SIZE);
 999
1000                         PVR_DUMPDEBUG_LOG(("%s  * Request (0x%016llX): %s (%s), %s 0x%010llX.",
1001                                                           (bBIFSummary)?"":"    ",
1002                                                           ui64ReqStatus,
1003                                           pszTagID,
1004                                           pszTagSB,
1005                                           (bRead)?"Reading from":"Writing to",
1006                                           ui64Addr));
1007                 }
1008
1009                 /* Check if the host thinks this fault is valid */
1010                 if(bBIFSummary)
1011                 {
1012                         IMG_UINT32 ui32PC =
1013                                 (ui64MMUStatus & ~RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_CLRMSK) >>
1014                                         RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_SHIFT;
1015                         IMG_DEV_VIRTADDR sFaultDevVAddr;
1016                         IMG_DEV_PHYADDR sPCDevPAddr;
1017
1018                         sPCDevPAddr.uiAddr = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_CAT_BASEN(ui32PC));
1019                         sFaultDevVAddr.uiAddr = (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK);
1020                         RGXCheckFaultAddress(psDevInfo, &sFaultDevVAddr, &sPCDevPAddr);
1021                 }
1022
1023         }
1024
1025 }
1026 #endif
1027
1028
1029 #if defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
1030 /*!
1031 *******************************************************************************
1032
1033  @Function      _RGXDumpRGXMMUFaultStatus
1034
1035  @Description
1036
1037  Dump MMU Fault status in human readable form.
1038
1039  @Input psDevInfo                               - RGX device info
1040  @Input ui64MMUStatus                   - MMU Status register value
1041  @Input bSummary                                - Flag to check whether the function is called
1042                                                                   as a part of the debug dump summary or
1043                                                                   as a part of a HWR log
1044  @Return   IMG_VOID
1045
1046 ******************************************************************************/
1047 static IMG_VOID _RGXDumpRGXMMUFaultStatus(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1048                                           PVRSRV_RGXDEV_INFO    *psDevInfo,
1049                                           IMG_UINT64            ui64MMUStatus,
1050                                           IMG_BOOL              bSummary)
1051 {
1052         if (ui64MMUStatus == 0x0)
1053         {
1054                 PVR_DUMPDEBUG_LOG(("MMU (Core) - OK"));
1055         }
1056         else
1057         {
1058                 IMG_UINT32 ui32PC        = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_CONTEXT_CLRMSK) >>
1059                                            RGX_CR_MMU_FAULT_STATUS_CONTEXT_SHIFT;
1060                 IMG_UINT64 ui64Addr      = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_ADDRESS_CLRMSK) >>
1061                                            RGX_CR_MMU_FAULT_STATUS_ADDRESS_SHIFT;
1062                 IMG_UINT32 ui32Requester = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_REQ_ID_CLRMSK) >>
1063                                            RGX_CR_MMU_FAULT_STATUS_REQ_ID_SHIFT;
1064                 IMG_UINT32 ui32SideBand  = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_TAG_SB_CLRMSK) >>
1065                                            RGX_CR_MMU_FAULT_STATUS_TAG_SB_SHIFT;
1066                 IMG_UINT32 ui32MMULevel  = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_LEVEL_CLRMSK) >>
1067                                            RGX_CR_MMU_FAULT_STATUS_LEVEL_SHIFT;
1068                 IMG_BOOL bRead           = (ui64MMUStatus & RGX_CR_MMU_FAULT_STATUS_RNW_EN) != 0;
1069                 IMG_BOOL bFault          = (ui64MMUStatus & RGX_CR_MMU_FAULT_STATUS_FAULT_EN) != 0;
1070                 IMG_BOOL bROFault        = ((ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_TYPE_CLRMSK) >>
1071                                             RGX_CR_MMU_FAULT_STATUS_TYPE_SHIFT) == 0x2;
1072                 IMG_BOOL bProtFault      = ((ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_TYPE_CLRMSK) >>
1073                                             RGX_CR_MMU_FAULT_STATUS_TYPE_SHIFT) == 0x3;
1074                 IMG_CHAR aszScratch[RGX_DEBUG_STR_SIZE];
1075                 IMG_CHAR *pszTagID;
1076                 IMG_CHAR *pszTagSB;
1077
1078                 _RGXDecodeMMUReqTags(ui32Requester, ui32SideBand, &pszTagID, &pszTagSB, aszScratch, RGX_DEBUG_STR_SIZE);
1079
1080                 PVR_DUMPDEBUG_LOG(("%sMMU (Core) - FAULT:",  (bSummary)?"":"    "));
1081                 PVR_DUMPDEBUG_LOG(("%s  * MMU status (0x%016llX): PC = %d, %s 0x%010llX, %s (%s)%s%s%s%s.",
1082                                                   (bSummary)?"":"    ",
1083                                                   ui64MMUStatus,
1084                                                   ui32PC,
1085                                   (bRead)?"Reading from":"Writing to",
1086                                                   ui64Addr,
1087                                                   pszTagID,
1088                                                   pszTagSB,
1089                                                   (bFault)?", Fault":"",
1090                                                   (bROFault)?", Read Only fault":"",
1091                                                   (bProtFault)?", PM/META protection fault":"",
1092                                                   _RGXDecodeMMULevel(ui32MMULevel)));
1093         }
1094 }
1095
1096
1097 /*!
1098 *******************************************************************************
1099
1100  @Function      _RGXDumpRGXMMUMetaFaultStatus
1101
1102  @Description
1103
1104  Dump MMU Meta Fault state in human readable form.
1105
1106  @Input psDevInfo                               - RGX device info
1107  @Input ui64MMUStatus                   - MMU Status register value
1108  @Input bSummary                                - Flag to check whether the function is called
1109                                                                   as a part of the debug dump summary or
1110                                                                   as a part of a HWR log
1111  @Return   IMG_VOID
1112
1113 ******************************************************************************/
1114 static IMG_VOID _RGXDumpRGXMMUMetaFaultStatus(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1115                                               PVRSRV_RGXDEV_INFO    *psDevInfo,
1116                                               IMG_UINT64            ui64MMUStatus,
1117                                               IMG_BOOL              bSummary)
1118 {
1119         if (ui64MMUStatus == 0x0)
1120         {
1121                 PVR_DUMPDEBUG_LOG(("MMU (Meta) - OK"));
1122         }
1123         else
1124         {
1125                 IMG_UINT32 ui32PC        = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_CONTEXT_CLRMSK) >>
1126                                            RGX_CR_MMU_FAULT_STATUS_META_CONTEXT_SHIFT;
1127                 IMG_UINT64 ui64Addr      = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_ADDRESS_CLRMSK) >>
1128                                            RGX_CR_MMU_FAULT_STATUS_META_ADDRESS_SHIFT;
1129                 IMG_UINT32 ui32SideBand  = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_TAG_SB_CLRMSK) >>
1130                                            RGX_CR_MMU_FAULT_STATUS_META_TAG_SB_SHIFT;
1131                 IMG_UINT32 ui32Requester = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_REQ_ID_CLRMSK) >>
1132                                            RGX_CR_MMU_FAULT_STATUS_META_REQ_ID_SHIFT;
1133                 IMG_UINT32 ui32MMULevel  = (ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_LEVEL_CLRMSK) >>
1134                                            RGX_CR_MMU_FAULT_STATUS_META_LEVEL_SHIFT;
1135                 IMG_BOOL bRead           = (ui64MMUStatus & RGX_CR_MMU_FAULT_STATUS_META_RNW_EN) != 0;
1136                 IMG_BOOL bFault          = (ui64MMUStatus & RGX_CR_MMU_FAULT_STATUS_META_FAULT_EN) != 0;
1137                 IMG_BOOL bROFault        = ((ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_TYPE_CLRMSK) >>
1138                                             RGX_CR_MMU_FAULT_STATUS_META_TYPE_SHIFT) == 0x2;
1139                 IMG_BOOL bProtFault      = ((ui64MMUStatus & ~RGX_CR_MMU_FAULT_STATUS_META_TYPE_CLRMSK) >>
1140                                             RGX_CR_MMU_FAULT_STATUS_META_TYPE_SHIFT) == 0x3;
1141                 IMG_CHAR aszScratch[RGX_DEBUG_STR_SIZE];
1142                 IMG_CHAR *pszTagID;
1143                 IMG_CHAR *pszTagSB;
1144
1145                 _RGXDecodeMMUReqTags(ui32Requester, ui32SideBand, &pszTagID, &pszTagSB, aszScratch, RGX_DEBUG_STR_SIZE);
1146
1147                 PVR_DUMPDEBUG_LOG(("%sMMU (Meta) - FAULT:",  (bSummary)?"":"    "));
1148                 PVR_DUMPDEBUG_LOG(("%s  * MMU status (0x%016llX): PC = %d, %s 0x%010llX, %s (%s)%s%s%s%s.",
1149                                                   (bSummary)?"":"    ",
1150                                                   ui64MMUStatus,
1151                                                   ui32PC,
1152                                   (bRead)?"Reading from":"Writing to",
1153                                                   ui64Addr,
1154                                                   pszTagID,
1155                                                   pszTagSB,
1156                                                   (bFault)?", Fault":"",
1157                                                   (bROFault)?", Read Only fault":"",
1158                                                   (bProtFault)?", PM/META protection fault":"",
1159                                                   _RGXDecodeMMULevel(ui32MMULevel)));
1160         }
1161 }
1162 #endif
1163
1164
1165 /*!
1166 *******************************************************************************
1167
1168  @Function      _RGXDumpFWAssert
1169
1170  @Description
1171
1172  Dump FW assert strings when a thread asserts.
1173
1174  @Input psRGXFWIfTraceBufCtl    - RGX FW trace buffer
1175
1176  @Return   IMG_VOID
1177
1178 ******************************************************************************/
1179 static IMG_VOID _RGXDumpFWAssert(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1180                                  RGXFWIF_TRACEBUF *psRGXFWIfTraceBufCtl)
1181 {
1182         IMG_CHAR    *pszTraceAssertPath;
1183         IMG_CHAR    *pszTraceAssertInfo;
1184         IMG_INT32   ui32TraceAssertLine;
1185         IMG_UINT32  i;
1186
1187         for (i = 0; i < RGXFW_THREAD_NUM; i++)
1188         {
1189                 pszTraceAssertPath = psRGXFWIfTraceBufCtl->sTraceBuf[i].sAssertBuf.szPath;
1190                 pszTraceAssertInfo = psRGXFWIfTraceBufCtl->sTraceBuf[i].sAssertBuf.szInfo;
1191                 ui32TraceAssertLine = psRGXFWIfTraceBufCtl->sTraceBuf[i].sAssertBuf.ui32LineNum;
1192
1193                 /* print non null assert strings */
1194                 if (*pszTraceAssertInfo)
1195                 {
1196                         PVR_DUMPDEBUG_LOG(("FW-T%d Assert: %s (%s:%d)",
1197                                           i, pszTraceAssertInfo, pszTraceAssertPath, ui32TraceAssertLine));
1198                 }
1199         }
1200 }
1201
1202 static IMG_VOID _RGXDumpFWPoll(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1203                                RGXFWIF_TRACEBUF *psRGXFWIfTraceBufCtl)
1204 {
1205         IMG_UINT32 i;
1206         for (i = 0; i < RGXFW_THREAD_NUM; i++)
1207         {
1208                 if (psRGXFWIfTraceBufCtl->aui32CrPollAddr[i])
1209                 {
1210                         PVR_DUMPDEBUG_LOG(("T%u polling %s (reg:0x%08X mask:0x%08X)",
1211                                           i,
1212                                           ((psRGXFWIfTraceBufCtl->aui32CrPollAddr[i] & RGXFW_POLL_TYPE_SET)?("set"):("unset")),
1213                                           psRGXFWIfTraceBufCtl->aui32CrPollAddr[i] & ~RGXFW_POLL_TYPE_SET,
1214                                           psRGXFWIfTraceBufCtl->aui32CrPollMask[i]));
1215                 }
1216         }
1217
1218 }
1219
1220 static IMG_VOID _RGXDumpFWHWRInfo(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1221                                   RGXFWIF_TRACEBUF *psRGXFWIfTraceBufCtl, PVRSRV_RGXDEV_INFO *psDevInfo)
1222 {
1223         IMG_BOOL                bAnyLocked = IMG_FALSE;
1224         IMG_UINT32              dm, i;
1225         IMG_UINT32              ui32LineSize;
1226         IMG_CHAR                *pszLine, *pszTemp;
1227         const IMG_CHAR          *apszDmNames[RGXFWIF_DM_MAX + 1] = { "GP(", "2D(", "TA(", "3D(", "CDM(",
1228 #if defined(RGX_FEATURE_RAY_TRACING)
1229                                                                  "RTU(", "SHG(",
1230 #endif /* RGX_FEATURE_RAY_TRACING */
1231                                                                  NULL };
1232
1233         const IMG_CHAR          *pszMsgHeader = "Number of HWR: ";
1234         IMG_CHAR                        *pszLockupType = "";
1235         RGXFWIF_HWRINFOBUF      *psHWInfoBuf = psDevInfo->psRGXFWIfHWRInfoBuf;
1236         RGX_HWRINFO             *psHWRInfo;
1237         IMG_UINT32              ui32MsgHeaderSize = OSStringLength(pszMsgHeader);
1238         IMG_UINT32                      ui32HWRRecoveryFlags;
1239         IMG_UINT32                      ui32ReadIndex;
1240
1241         for (dm = 0; dm < RGXFWIF_DM_MAX; dm++)
1242         {
1243                 if (psRGXFWIfTraceBufCtl->aui16HwrDmLockedUpCount[dm]  ||
1244                     psRGXFWIfTraceBufCtl->aui16HwrDmOverranCount[dm])
1245                 {
1246                         bAnyLocked = IMG_TRUE;
1247                         break;
1248                 }
1249         }
1250
1251         if (!bAnyLocked && (psRGXFWIfTraceBufCtl->ui32HWRStateFlags & RGXFWIF_HWR_HARDWARE_OK))
1252         {
1253                 /* No HWR situation, print nothing */
1254                 return;
1255         }
1256
1257         ui32LineSize = sizeof(IMG_CHAR) * (     ui32MsgHeaderSize +
1258                         (RGXFWIF_DM_MAX*(       4/*DM name + left parenthesis*/ +
1259                                                                 5/*UINT16 max num of digits*/ +
1260                                                                 1/*slash*/ +
1261                                                                 5/*UINT16 max num of digits*/ +
1262                                                                 3/*right parenthesis + comma + space*/)) +
1263                         7 + (RGXFWIF_DM_MAX*6)/* FALSE() + (UINT16 max num + comma) per DM */ +
1264                         1/* \0 */);
1265
1266         pszLine = OSAllocMem(ui32LineSize);
1267         if (pszLine == IMG_NULL)
1268         {
1269                 PVR_DPF((PVR_DBG_ERROR,"_RGXDumpRGXDebugSummary: Out of mem allocating line string (size: %d)", ui32LineSize));
1270                 return;
1271         }
1272
1273         OSStringCopy(pszLine,pszMsgHeader);
1274         pszTemp = pszLine + ui32MsgHeaderSize;
1275
1276         for (dm = 0; (dm < RGXFWIF_DM_MAX) && (apszDmNames[dm] != IMG_NULL); dm++)
1277         {
1278                 OSStringCopy(pszTemp,apszDmNames[dm]);
1279                 pszTemp += OSStringLength(apszDmNames[dm]);
1280                 pszTemp += OSSNPrintf(pszTemp,
1281                                 5 + 1 + 5 + 1 + 5 + 1 + 1 + 1 + 1 /* UINT16 + slash + UINT16 + plus + UINT16 + right parenthesis + comma + space + \0 */,
1282                                 "%u/%u+%u), ",
1283                                 psRGXFWIfTraceBufCtl->aui16HwrDmRecoveredCount[dm],
1284                                 psRGXFWIfTraceBufCtl->aui16HwrDmLockedUpCount[dm],
1285                                 psRGXFWIfTraceBufCtl->aui16HwrDmOverranCount[dm]);
1286         }
1287
1288         OSStringCopy(pszTemp, "FALSE(");
1289         pszTemp += 6;
1290
1291         for (dm = 0; (dm < RGXFWIF_DM_MAX) && (apszDmNames[dm] != IMG_NULL); dm++)
1292         {
1293                 pszTemp += OSSNPrintf(pszTemp,
1294                                 5 + 1 + 1 /* UINT16 max num + comma + \0 */,
1295                                 (dm < RGXFWIF_DM_MAX-1 ? "%u," : "%u)"),
1296                                 psRGXFWIfTraceBufCtl->aui16HwrDmFalseDetectCount[dm]);
1297         }
1298
1299         PVR_DUMPDEBUG_LOG((pszLine));
1300
1301         OSFreeMem(pszLine);
1302
1303         /* Print out per HWR info */
1304         for (dm = 0; (dm < RGXFWIF_DM_MAX) && (apszDmNames[dm] != IMG_NULL); dm++)
1305         {
1306                 if (dm == RGXFWIF_DM_GP)
1307                 {
1308                         PVR_DUMPDEBUG_LOG(("DM %d (GP)", dm));
1309                 }
1310                 else
1311                 {
1312                         PVR_DUMPDEBUG_LOG(("DM %d (HWRflags 0x%08x)", dm, psRGXFWIfTraceBufCtl->aui32HWRRecoveryFlags[dm]));
1313                 }
1314
1315                 ui32ReadIndex = 0;
1316                 for(i = 0 ; i < RGXFWIF_HWINFO_MAX ; i++)
1317                 {
1318                         psHWRInfo = &psHWInfoBuf->sHWRInfo[ui32ReadIndex];
1319
1320                         if((psHWRInfo->eDM == dm) && (psHWRInfo->ui32HWRNumber != 0))
1321                         {
1322                                 ui32HWRRecoveryFlags = psHWRInfo->ui32HWRRecoveryFlags;
1323                                 if(ui32HWRRecoveryFlags & RGXFWIF_DM_STATE_GUILTY_LOCKUP) { pszLockupType = ", Guilty Lockup"; }
1324                                 else if (ui32HWRRecoveryFlags & RGXFWIF_DM_STATE_INNOCENT_LOCKUP) { pszLockupType = ", Innocent Lockup"; }
1325                                 else if (ui32HWRRecoveryFlags & RGXFWIF_DM_STATE_GUILTY_OVERRUNING) { pszLockupType = ", Guilty Overrun"; }
1326                                 else if (ui32HWRRecoveryFlags & RGXFWIF_DM_STATE_GUILTY_LOCKUP) { pszLockupType = ", Innocent Overrun"; }
1327
1328                                 PVR_DUMPDEBUG_LOG(("  Recovery %d: PID = %d, frame = %d, HWRTData = 0x%08X, EventStatus = 0x%08X, CRTimer = 0x%012llX%s",
1329                                                                   psHWRInfo->ui32HWRNumber,
1330                                                                   psHWRInfo->ui32PID,
1331                                                                   psHWRInfo->ui32FrameNum,
1332                                                                   psHWRInfo->ui32ActiveHWRTData,
1333                                                                   psHWRInfo->ui32EventStatus,
1334                                                                   psHWRInfo->ui64CRTimer,
1335                                                                   pszLockupType));
1336
1337                                 switch(psHWRInfo->eHWRType)
1338                                 {
1339 #if !defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
1340                                         case RGX_HWRTYPE_BIF0FAULT:
1341                                         case RGX_HWRTYPE_BIF1FAULT:
1342                                         {
1343                                                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXFWIF_HWRTYPE_BIF_BANK_GET(psHWRInfo->eHWRType),
1344                                                                                 psHWRInfo->uHWRData.sBIFInfo.ui64BIFMMUStatus,
1345                                                                                 psHWRInfo->uHWRData.sBIFInfo.ui64BIFReqStatus,
1346                                                                                 IMG_FALSE);
1347                                         }
1348                                         break;
1349 #if defined(RGX_FEATURE_CLUSTER_GROUPING)
1350                                         case RGX_HWRTYPE_TEXASBIF0FAULT:
1351                                         {
1352                                                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS_BIF,
1353                                                                                 psHWRInfo->uHWRData.sBIFInfo.ui64BIFMMUStatus,
1354                                                                                 psHWRInfo->uHWRData.sBIFInfo.ui64BIFReqStatus,
1355                                                                                 IMG_FALSE);
1356                                         }
1357                                         break;
1358 #endif
1359 #else
1360                                         case RGX_HWRTYPE_MMUFAULT:
1361                                         {
1362                                                 _RGXDumpRGXMMUFaultStatus(pfnDumpDebugPrintf, psDevInfo,
1363                                                                           psHWRInfo->uHWRData.sMMUInfo.ui64MMUStatus,
1364                                                                           IMG_FALSE);
1365                                         }
1366                                         break;
1367
1368                                         case RGX_HWRTYPE_MMUMETAFAULT:
1369                                         {
1370                                                 _RGXDumpRGXMMUMetaFaultStatus(pfnDumpDebugPrintf, psDevInfo,
1371                                                                               psHWRInfo->uHWRData.sMMUInfo.ui64MMUStatus,
1372                                                                               IMG_FALSE);
1373                                         }
1374                                         break;
1375 #endif
1376
1377                                         case RGX_HWRTYPE_POLLFAILURE:
1378                                         {
1379                                                 PVR_DUMPDEBUG_LOG(("    T%u polling %s (reg:0x%08X mask:0x%08X)",
1380                                                                                   psHWRInfo->uHWRData.sPollInfo.ui32ThreadNum,
1381                                                                                   ((psHWRInfo->uHWRData.sPollInfo.ui32CrPollAddr & RGXFW_POLL_TYPE_SET)?("set"):("unset")),
1382                                                                                   psHWRInfo->uHWRData.sPollInfo.ui32CrPollAddr & ~RGXFW_POLL_TYPE_SET,
1383                                                                                   psHWRInfo->uHWRData.sPollInfo.ui32CrPollMask));
1384                                         }
1385                                         break;
1386
1387                                         case RGX_HWRTYPE_OVERRUN:
1388                                         case RGX_HWRTYPE_UNKNOWNFAILURE:
1389                                         {
1390                                                 /* Nothing to dump */
1391                                         }
1392                                         break;
1393
1394                                         default:
1395                                         {
1396                                                 PVR_ASSERT(IMG_FALSE);
1397                                         }
1398                                         break;
1399                                 }
1400                         }
1401
1402                         if(ui32ReadIndex == RGXFWIF_HWINFO_MAX_FIRST - 1)
1403                                                         ui32ReadIndex = psHWInfoBuf->ui32WriteIndex;
1404                         else
1405                                 ui32ReadIndex = (ui32ReadIndex + 1) - (ui32ReadIndex / RGXFWIF_HWINFO_LAST_INDEX) * RGXFWIF_HWINFO_MAX_LAST;
1406                 }
1407         }
1408 }
1409
1410 #if !defined(NO_HARDWARE)
1411
1412 /*!
1413 *******************************************************************************
1414
1415  @Function      _CheckForPendingPage
1416
1417  @Description
1418
1419  Check if the MMU indicates it is blocked on a pending page
1420
1421  @Input psDevInfo        - RGX device info
1422
1423  @Return   IMG_BOOL      - IMG_TRUE if there is a pending page
1424
1425 ******************************************************************************/
1426 static INLINE IMG_BOOL _CheckForPendingPage(PVRSRV_RGXDEV_INFO *psDevInfo)
1427 {
1428         IMG_UINT32 ui32BIFMMUEntry;
1429
1430         ui32BIFMMUEntry = OSReadHWReg32(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_MMU_ENTRY);
1431
1432         if(ui32BIFMMUEntry & RGX_CR_BIF_MMU_ENTRY_PENDING_EN)
1433         {
1434                 return IMG_TRUE;
1435         }
1436         else
1437         {
1438                 return IMG_FALSE;
1439         }
1440 }
1441
1442 /*!
1443 *******************************************************************************
1444
1445  @Function      _GetPendingPageInfo
1446
1447  @Description
1448
1449  Get information about the pending page from the MMU status registers
1450
1451  @Input psDevInfo        - RGX device info
1452  @Output psDevVAddr      - The device virtual address of the pending MMU address translation
1453  @Output pui32CatBase    - The page catalog base
1454  @Output pui32DataType   - The MMU entry data type
1455
1456  @Return   void
1457
1458 ******************************************************************************/
1459 static void _GetPendingPageInfo(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_DEV_VIRTADDR *psDevVAddr,
1460                                                                         IMG_UINT32 *pui32CatBase,
1461                                                                         IMG_UINT32 *pui32DataType)
1462 {
1463         IMG_UINT64 ui64BIFMMUEntryStatus;
1464
1465         ui64BIFMMUEntryStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_MMU_ENTRY_STATUS);
1466
1467         psDevVAddr->uiAddr = (ui64BIFMMUEntryStatus & ~RGX_CR_BIF_MMU_ENTRY_STATUS_ADDRESS_CLRMSK);
1468
1469         *pui32CatBase = (ui64BIFMMUEntryStatus & ~RGX_CR_BIF_MMU_ENTRY_STATUS_CAT_BASE_CLRMSK) >>
1470                                                                 RGX_CR_BIF_MMU_ENTRY_STATUS_CAT_BASE_SHIFT;
1471
1472         *pui32DataType = (ui64BIFMMUEntryStatus & ~RGX_CR_BIF_MMU_ENTRY_STATUS_DATA_TYPE_CLRMSK) >>
1473                                                                 RGX_CR_BIF_MMU_ENTRY_STATUS_DATA_TYPE_SHIFT;
1474 }
1475
1476 #endif
1477
1478 /*!
1479 *******************************************************************************
1480
1481  @Function      _RGXDumpRGXDebugSummary
1482
1483  @Description
1484
1485  Dump a summary in human readable form with the RGX state
1486
1487  @Input psDevInfo        - RGX device info
1488
1489  @Return   IMG_VOID
1490
1491 ******************************************************************************/
1492 static IMG_VOID _RGXDumpRGXDebugSummary(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1493                                         PVRSRV_RGXDEV_INFO *psDevInfo, IMG_BOOL bRGXPoweredON)
1494 {
1495         IMG_CHAR *pszState;
1496         RGXFWIF_TRACEBUF *psRGXFWIfTraceBuf = psDevInfo->psRGXFWIfTraceBuf;
1497
1498         if (bRGXPoweredON)
1499         {
1500 #if defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
1501                 IMG_UINT64      ui64RegValMMUStatus;
1502
1503                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_MMU_FAULT_STATUS);
1504                 _RGXDumpRGXMMUFaultStatus(pfnDumpDebugPrintf, psDevInfo, ui64RegValMMUStatus, IMG_TRUE);
1505
1506                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_MMU_FAULT_STATUS_META);
1507                 _RGXDumpRGXMMUMetaFaultStatus(pfnDumpDebugPrintf, psDevInfo, ui64RegValMMUStatus, IMG_TRUE);
1508 #else
1509                 IMG_UINT64      ui64RegValMMUStatus, ui64RegValREQStatus;
1510
1511                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK0_MMU_STATUS);
1512                 ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK0_REQ_STATUS);
1513
1514                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF0, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
1515
1516                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK1_MMU_STATUS);
1517                 ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK1_REQ_STATUS);
1518
1519                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF1, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
1520
1521 #if defined(RGX_FEATURE_CLUSTER_GROUPING)
1522 #if defined(RGX_NUM_PHANTOMS)
1523                 {
1524                         IMG_UINT32  ui32Phantom;
1525
1526                         for (ui32Phantom = 0;  ui32Phantom < RGX_NUM_PHANTOMS;  ui32Phantom++)
1527                         {
1528                                 /* This can't be done as it may interfere with the FW... */
1529                                 /*OSWriteHWReg64(RGX_CR_TEXAS_INDIRECT, ui32Phantom);*/
1530
1531                                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_MMU_STATUS);
1532                                 ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_REQ_STATUS);
1533
1534                                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
1535                         }
1536                 }
1537 #else
1538                 ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_MMU_STATUS);
1539                 ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_REQ_STATUS);
1540
1541                 _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS_BIF, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
1542 #endif
1543 #endif
1544 #endif
1545
1546 #if !defined(NO_HARDWARE)
1547                 if(_CheckForPendingPage(psDevInfo))
1548                 {
1549                         IMG_UINT32 ui32CatBase;
1550                         IMG_UINT32 ui32DataType;
1551                         IMG_DEV_VIRTADDR sDevVAddr;
1552
1553                         PVR_DUMPDEBUG_LOG(("MMU Pending page: Yes"));
1554
1555                         _GetPendingPageInfo(psDevInfo, &sDevVAddr, &ui32CatBase, &ui32DataType);
1556
1557                         if(ui32CatBase >= 8)
1558                         {
1559                                 PVR_DUMPDEBUG_LOG(("Cannot check address on PM cat base %u", ui32CatBase));
1560                         }
1561                         else
1562                         {
1563                                 IMG_DEV_PHYADDR sPCDevPAddr;
1564
1565                                 sPCDevPAddr.uiAddr = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_CAT_BASEN(ui32CatBase));
1566
1567                                 PVR_DUMPDEBUG_LOG(("Checking device virtual address " IMG_DEV_VIRTADDR_FMTSPEC
1568                                                         " on cat base %u. PC Addr = 0x%llX",
1569                                                                 (unsigned long long) sDevVAddr.uiAddr,
1570                                                                 ui32CatBase,
1571                                                                 (unsigned long long) sPCDevPAddr.uiAddr));
1572                                 RGXCheckFaultAddress(psDevInfo, &sDevVAddr, &sPCDevPAddr);
1573                         }
1574                 }
1575 #endif /* NO_HARDWARE */
1576         }
1577
1578         /* Firmware state */
1579         switch (psDevInfo->psDeviceNode->eHealthStatus)
1580         {
1581                 case PVRSRV_DEVICE_HEALTH_STATUS_OK:
1582                 {
1583                         pszState = "OK";
1584                         break;
1585                 }
1586
1587                 case PVRSRV_DEVICE_HEALTH_STATUS_NOT_RESPONDING:
1588                 {
1589                         pszState = "NOT RESPONDING";
1590                         break;
1591                 }
1592
1593                 case PVRSRV_DEVICE_HEALTH_STATUS_DEAD:
1594                 {
1595                         pszState = "DEAD";
1596                         break;
1597                 }
1598
1599                 default:
1600                 {
1601                         pszState = "UNKNOWN";
1602                         break;
1603                 }
1604         }
1605
1606         if (psRGXFWIfTraceBuf == IMG_NULL)
1607         {
1608                 PVR_DUMPDEBUG_LOG(("RGX FW State: %s", pszState));
1609
1610                 /* can't dump any more information */
1611                 return;
1612         }
1613
1614         PVR_DUMPDEBUG_LOG(("RGX FW State: %s (HWRState 0x%08x)", pszState, psRGXFWIfTraceBuf->ui32HWRStateFlags));
1615         PVR_DUMPDEBUG_LOG(("RGX FW Power State: %s (APM %s: %d ok, %d denied, %d other, %d total)",
1616                           pszPowStateName[psRGXFWIfTraceBuf->ePowState],
1617                           (psDevInfo->pvAPMISRData)?"enabled":"disabled",
1618                           psDevInfo->ui32ActivePMReqOk,
1619                           psDevInfo->ui32ActivePMReqDenied,
1620                           psDevInfo->ui32ActivePMReqTotal - psDevInfo->ui32ActivePMReqOk - psDevInfo->ui32ActivePMReqDenied,
1621                           psDevInfo->ui32ActivePMReqTotal));
1622
1623
1624         _RGXDumpFWAssert(pfnDumpDebugPrintf, psRGXFWIfTraceBuf);
1625
1626         _RGXDumpFWPoll(pfnDumpDebugPrintf, psRGXFWIfTraceBuf);
1627
1628         _RGXDumpFWHWRInfo(pfnDumpDebugPrintf, psRGXFWIfTraceBuf, psDevInfo);
1629
1630 }
1631
1632 static IMG_VOID _RGXDumpMetaSPExtraDebugInfo(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1633                                              PVRSRV_RGXDEV_INFO *psDevInfo)
1634 {
1635 /* List of extra META Slave Port debug registers */
1636 #define RGX_META_SP_EXTRA_DEBUG \
1637                         X(RGX_CR_META_SP_MSLVCTRL0) \
1638                         X(RGX_CR_META_SP_MSLVCTRL1) \
1639                         X(RGX_CR_META_SP_MSLVIRQSTATUS) \
1640                         X(RGX_CR_META_SP_MSLVIRQENABLE) \
1641                         X(RGX_CR_META_SP_MSLVIRQLEVEL)
1642
1643         IMG_UINT32 ui32Idx, ui32RegIdx;
1644         IMG_UINT32 ui32RegVal;
1645         IMG_UINT32 ui32RegAddr;
1646
1647         const IMG_UINT32 aui32DebugRegAddr [] = {
1648 #define X(A) A,
1649                 RGX_META_SP_EXTRA_DEBUG
1650 #undef X
1651                 };
1652
1653         const IMG_CHAR* apszDebugRegName [] = {
1654 #define X(A) #A,
1655         RGX_META_SP_EXTRA_DEBUG
1656 #undef X
1657         };
1658
1659         const IMG_UINT32 aui32Debug2RegAddr [] = {0xA28, 0x0A30, 0x0A38};
1660
1661         PVR_DUMPDEBUG_LOG(("META Slave Port extra debug:"));
1662
1663         /* dump first set of Slave Port debug registers */
1664         for (ui32Idx = 0; ui32Idx < sizeof(aui32DebugRegAddr)/sizeof(IMG_UINT32); ui32Idx++)
1665         {
1666                 const IMG_CHAR* pszRegName = apszDebugRegName[ui32Idx];
1667
1668                 ui32RegAddr = aui32DebugRegAddr[ui32Idx];
1669                 ui32RegVal = OSReadHWReg32(psDevInfo->pvRegsBaseKM, ui32RegAddr);
1670                 PVR_DUMPDEBUG_LOG(("  * %s: 0x%8.8X", pszRegName, ui32RegVal));
1671         }
1672
1673         /* dump second set of Slave Port debug registers */
1674         for (ui32Idx = 0; ui32Idx < 4; ui32Idx++)
1675         {
1676                 OSWriteHWReg32(psDevInfo->pvRegsBaseKM, 0xA20, ui32Idx);
1677                 ui32RegVal = OSReadHWReg32(psDevInfo->pvRegsBaseKM, 0xA20);
1678                 PVR_DUMPDEBUG_LOG(("  * 0xA20[%d]: 0x%8.8X", ui32Idx, ui32RegVal));
1679
1680         }
1681
1682         for (ui32RegIdx = 0; ui32RegIdx < sizeof(aui32Debug2RegAddr)/sizeof(IMG_UINT32); ui32RegIdx++)
1683         {
1684                 ui32RegAddr = aui32Debug2RegAddr[ui32RegIdx];
1685                 for (ui32Idx = 0; ui32Idx < 2; ui32Idx++)
1686                 {
1687                         OSWriteHWReg32(psDevInfo->pvRegsBaseKM, ui32RegAddr, ui32Idx);
1688                         ui32RegVal = OSReadHWReg32(psDevInfo->pvRegsBaseKM, ui32RegAddr);
1689                         PVR_DUMPDEBUG_LOG(("  * 0x%X[%d]: 0x%8.8X", ui32RegAddr, ui32Idx, ui32RegVal));
1690                 }
1691         }
1692
1693 }
1694
1695 /*
1696         RGXDumpDebugInfo
1697 */
1698 IMG_VOID RGXDumpDebugInfo(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1699                           PVRSRV_RGXDEV_INFO    *psDevInfo)
1700 {
1701         IMG_UINT32 i;
1702
1703         for(i=0;i<=DEBUG_REQUEST_VERBOSITY_MAX;i++)
1704         {
1705                 RGXDebugRequestProcess(pfnDumpDebugPrintf, psDevInfo, i);
1706         }
1707 }
1708
1709
1710 #if defined(PVRSRV_ENABLE_FW_TRACE_DEBUGFS)
1711 /*
1712  *  Array of all the Firmware Trace log IDs used to convert the trace data.
1713  */
1714 typedef struct _TRACEBUF_LOG_ {
1715         RGXFW_LOG_SFids  eSFId;
1716         IMG_CHAR                 *pszName;
1717         IMG_CHAR                 *pszFmt;
1718         IMG_UINT32               ui32ArgNum;
1719 } TRACEBUF_LOG;
1720
1721 TRACEBUF_LOG aLogDefinitions[] = {
1722 #define X(a, b, c, d, e) {RGXFW_LOG_CREATESFID(a,b,e), #c, d, e},
1723         RGXFW_LOG_SFIDLIST
1724 #undef X
1725 };
1726
1727 #define NARGS_MASK ~(0xF<<16)
1728 static IMG_BOOL _FirmwareTraceIntegrityCheck(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf)
1729 {
1730         TRACEBUF_LOG  *psLogDef    = &aLogDefinitions[0];
1731         IMG_BOOL      bIntegrityOk = IMG_TRUE;
1732
1733         /*
1734          *  For every log ID, check the format string and number of arguments is valid.
1735          */
1736         while (psLogDef->eSFId != RGXFW_SF_LAST)
1737         {
1738                 IMG_UINT32    ui32Count;
1739                 IMG_CHAR      *pszString;
1740                 TRACEBUF_LOG  *psLogDef2;
1741
1742                 /*
1743                  * Check the number of arguments matches the number of '%' in the string and
1744                  * check that no string uses %s which is not supported as it requires a
1745                  * pointer to memory that is not going to be valid.
1746                  */
1747                 pszString = psLogDef->pszFmt;
1748                 ui32Count = 0;
1749
1750                 while (*pszString != '\0')
1751                 {
1752                         if (*pszString++ == '%')
1753                         {
1754                                 ui32Count++;
1755                                 if (*pszString == 's')
1756                                 {
1757                                         bIntegrityOk = IMG_FALSE;
1758                                         PVR_DUMPDEBUG_LOG(("Integrity Check FAIL: %s has an unsupported type not recognized (fmt: %%%c). Please fix.",
1759                                                                           psLogDef->pszName, *pszString));
1760                                 }
1761                                 else if (*pszString == '%')
1762                                 {
1763                                         /* Double % is a printable % sign and not a format string... */
1764                                         ui32Count--;
1765                                 }
1766                         }
1767                 }
1768
1769                 if (ui32Count != psLogDef->ui32ArgNum)
1770                 {
1771                         bIntegrityOk = IMG_FALSE;
1772                         PVR_DUMPDEBUG_LOG(("Integrity Check FAIL: %s has %d arguments but only %d are specified. Please fix.",
1773                                           psLogDef->pszName, ui32Count, psLogDef->ui32ArgNum));
1774                 }
1775
1776                 /* RGXDumpFirmwareTrace() has a hardcoded limit of supporting up to 20 arguments... */
1777                 if (ui32Count > 20)
1778                 {
1779                         bIntegrityOk = IMG_FALSE;
1780                         PVR_DUMPDEBUG_LOG(("Integrity Check FAIL: %s has %d arguments but a maximum of 20 are supported. Please fix.",
1781                                           psLogDef->pszName, ui32Count));
1782                 }
1783
1784                 /* Check the id number is unique (don't take into account the number of arguments) */
1785                 ui32Count = 0;
1786                 psLogDef2 = &aLogDefinitions[0];
1787
1788                 while (psLogDef2->eSFId != RGXFW_SF_LAST)
1789                 {
1790                         if ((psLogDef->eSFId & NARGS_MASK) == (psLogDef2->eSFId & NARGS_MASK))
1791                         {
1792                                 ui32Count++;
1793                         }
1794                         psLogDef2++;
1795                 }
1796
1797                 if (ui32Count != 1)
1798                 {
1799                         bIntegrityOk = IMG_FALSE;
1800                         PVR_DUMPDEBUG_LOG(("Integrity Check FAIL: %s id %x is not unique, there are %d more. Please fix.",
1801                                           psLogDef->pszName, psLogDef->eSFId, ui32Count - 1));
1802                 }
1803
1804                 /* Move to the next log ID... */
1805                 psLogDef++;
1806         }
1807
1808         return bIntegrityOk;
1809 }
1810
1811 IMG_VOID RGXDumpFirmwareTrace(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1812                               PVRSRV_RGXDEV_INFO  *psDevInfo)
1813 {
1814         RGXFWIF_TRACEBUF  *psRGXFWIfTraceBufCtl = psDevInfo->psRGXFWIfTraceBuf;
1815         static IMG_BOOL   bIntegrityCheckPassed = IMG_FALSE;
1816
1817         /* Check that the firmware trace is correctly defined... */
1818         if (!bIntegrityCheckPassed)
1819         {
1820                 bIntegrityCheckPassed = _FirmwareTraceIntegrityCheck(pfnDumpDebugPrintf);
1821                 if (!bIntegrityCheckPassed)
1822                 {
1823                         return;
1824                 }
1825         }
1826
1827         /* Dump FW trace information... */
1828         if (psRGXFWIfTraceBufCtl != IMG_NULL)
1829         {
1830                 IMG_CHAR    szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN];
1831                 IMG_UINT32  tid;
1832
1833                 /* Print the log type settings... */
1834                 if (psRGXFWIfTraceBufCtl->ui32LogType & RGXFWIF_LOG_TYPE_GROUP_MASK)
1835                 {
1836                         PVR_DUMPDEBUG_LOG(("Debug log type: %s ( " RGXFWIF_LOG_ENABLED_GROUPS_LIST_PFSPEC ")",
1837                                                           ((psRGXFWIfTraceBufCtl->ui32LogType & RGXFWIF_LOG_TYPE_TRACE)?("trace"):("tbi")),
1838                                                           RGXFWIF_LOG_ENABLED_GROUPS_LIST(psRGXFWIfTraceBufCtl->ui32LogType)
1839                                                           ));
1840                 }
1841                 else
1842                 {
1843                         PVR_DUMPDEBUG_LOG(("Debug log type: none"));
1844                 }
1845
1846                 /* Print the decoded log for each thread... */
1847                 for (tid = 0;  tid < RGXFW_THREAD_NUM;  tid++)
1848                 {
1849                         IMG_UINT32  *ui32TraceBuf = psRGXFWIfTraceBufCtl->sTraceBuf[tid].aui32TraceBuffer;
1850                         IMG_UINT32  ui32TracePtr  = psRGXFWIfTraceBufCtl->sTraceBuf[tid].ui32TracePointer;
1851                         IMG_UINT32  ui32Count     = 0;
1852
1853                         while (ui32Count < RGXFW_TRACE_BUFFER_SIZE)
1854                         {
1855                                 IMG_UINT32  ui32Data, ui32DataToId;
1856
1857                                 /* Find the first valid log ID, skipping whitespace... */
1858                                 do
1859                                 {
1860                                         ui32Data     = ui32TraceBuf[ui32TracePtr];
1861                                         ui32DataToId = idToStringID(ui32Data);
1862
1863                                         /* If an unrecognized id is found check if it is valid, if it is tracebuf needs updating. */
1864                                         if (ui32DataToId == RGXFW_SF_LAST  &&  RGXFW_LOG_VALIDID(ui32Data))
1865                                         {
1866                                                 PVR_DUMPDEBUG_LOG(("ERROR: Unrecognized id (%x). From here on the trace might be wrong!", ui32Data));
1867                                                 return;
1868                                         }
1869
1870                                         /* Update the trace pointer... */
1871                                         ui32TracePtr = (ui32TracePtr + 1) % RGXFW_TRACE_BUFFER_SIZE;
1872                                         ui32Count++;
1873                                 } while ((RGXFW_SF_LAST == ui32DataToId  ||  ui32DataToId >= RGXFW_SF_FIRST)  &&
1874                                          ui32Count < RGXFW_TRACE_BUFFER_SIZE);
1875
1876                                 if (ui32Count < RGXFW_TRACE_BUFFER_SIZE)
1877                                 {
1878                                         IMG_UINT64  ui64RGXTimer;
1879
1880                                         /* If we hit the ASSERT message then this is the end of the log... */
1881                                         if (ui32Data == RGXFW_SF_MAIN_ASSERT_FAILED)
1882                                         {
1883                                                 PVR_DUMPDEBUG_LOG(("ASSERTION %s failed at %s:%u",
1884                                                                                   psRGXFWIfTraceBufCtl->sTraceBuf[tid].sAssertBuf.szInfo,
1885                                                                                   psRGXFWIfTraceBufCtl->sTraceBuf[tid].sAssertBuf.szPath,
1886                                                                                   psRGXFWIfTraceBufCtl->sTraceBuf[tid].sAssertBuf.ui32LineNum));
1887                                                 break;
1888                                         }
1889
1890                                         /*
1891                                          *  Print the trace string and provide up to 20 arguments which
1892                                          *  printf function will be able to use. We have already checked
1893                                          *  that no string uses more than this.
1894                                          */
1895                                         OSStringCopy(szBuffer, "%llu:T%u-%s> ");
1896                                         OSStringCopy(&szBuffer[OSStringLength(szBuffer)], SFs[ui32DataToId].name);
1897                                         szBuffer[OSStringLength(szBuffer)-1] = '\0';
1898                                         ui64RGXTimer = (IMG_UINT64)(ui32TraceBuf[(ui32TracePtr +  0) % RGXFW_TRACE_BUFFER_SIZE]) << 32 |
1899                                                        (IMG_UINT64)(ui32TraceBuf[(ui32TracePtr +  1) % RGXFW_TRACE_BUFFER_SIZE]);
1900                                         PVR_DUMPDEBUG_LOG((szBuffer, ui64RGXTimer, tid, groups[RGXFW_SF_GID(ui32Data)],
1901                                                                           ui32TraceBuf[(ui32TracePtr +  2) % RGXFW_TRACE_BUFFER_SIZE],
1902                                                                           ui32TraceBuf[(ui32TracePtr +  3) % RGXFW_TRACE_BUFFER_SIZE],
1903                                                                           ui32TraceBuf[(ui32TracePtr +  4) % RGXFW_TRACE_BUFFER_SIZE],
1904                                                                           ui32TraceBuf[(ui32TracePtr +  5) % RGXFW_TRACE_BUFFER_SIZE],
1905                                                                           ui32TraceBuf[(ui32TracePtr +  6) % RGXFW_TRACE_BUFFER_SIZE],
1906                                                                           ui32TraceBuf[(ui32TracePtr +  7) % RGXFW_TRACE_BUFFER_SIZE],
1907                                                                           ui32TraceBuf[(ui32TracePtr +  8) % RGXFW_TRACE_BUFFER_SIZE],
1908                                                                           ui32TraceBuf[(ui32TracePtr +  9) % RGXFW_TRACE_BUFFER_SIZE],
1909                                                                           ui32TraceBuf[(ui32TracePtr + 10) % RGXFW_TRACE_BUFFER_SIZE],
1910                                                                           ui32TraceBuf[(ui32TracePtr + 11) % RGXFW_TRACE_BUFFER_SIZE],
1911                                                                           ui32TraceBuf[(ui32TracePtr + 12) % RGXFW_TRACE_BUFFER_SIZE],
1912                                                                           ui32TraceBuf[(ui32TracePtr + 13) % RGXFW_TRACE_BUFFER_SIZE],
1913                                                                           ui32TraceBuf[(ui32TracePtr + 14) % RGXFW_TRACE_BUFFER_SIZE],
1914                                                                           ui32TraceBuf[(ui32TracePtr + 15) % RGXFW_TRACE_BUFFER_SIZE],
1915                                                                           ui32TraceBuf[(ui32TracePtr + 16) % RGXFW_TRACE_BUFFER_SIZE],
1916                                                                           ui32TraceBuf[(ui32TracePtr + 17) % RGXFW_TRACE_BUFFER_SIZE],
1917                                                                           ui32TraceBuf[(ui32TracePtr + 18) % RGXFW_TRACE_BUFFER_SIZE],
1918                                                                           ui32TraceBuf[(ui32TracePtr + 19) % RGXFW_TRACE_BUFFER_SIZE],
1919                                                                           ui32TraceBuf[(ui32TracePtr + 20) % RGXFW_TRACE_BUFFER_SIZE],
1920                                                                           ui32TraceBuf[(ui32TracePtr + 21) % RGXFW_TRACE_BUFFER_SIZE]));
1921
1922                                         /* Update the trace pointer... */
1923                                         ui32TracePtr = (ui32TracePtr + 2 + RGXFW_SF_PARAMNUM(ui32Data)) % RGXFW_TRACE_BUFFER_SIZE;
1924                                         ui32Count    = (ui32Count    + 2 + RGXFW_SF_PARAMNUM(ui32Data));
1925                                 }
1926                         }
1927                 }
1928         }
1929 }
1930 #endif
1931
1932
1933 static IMG_CHAR* _RGXGetDebugDevPowerStateString(PVRSRV_DEV_POWER_STATE ePowerState)
1934 {
1935         switch(ePowerState)
1936         {
1937                 case PVRSRV_DEV_POWER_STATE_DEFAULT: return "DEFAULT";
1938                 case PVRSRV_DEV_POWER_STATE_OFF: return "OFF";
1939                 case PVRSRV_DEV_POWER_STATE_ON: return "ON";
1940                 default: return "UNKNOWN";
1941         }
1942 }
1943
1944 IMG_VOID RGXDebugRequestProcess(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
1945                                 PVRSRV_RGXDEV_INFO      *psDevInfo,
1946                                 IMG_UINT32                      ui32VerbLevel)
1947 {
1948         PVRSRV_ERROR eError = PVRSRVPowerLock();
1949         if (eError != PVRSRV_OK)
1950         {
1951                 PVR_DPF((PVR_DBG_ERROR, "RGXDebugRequestProcess : failed to acquire lock, error:0x%x", eError));
1952                 return;
1953         }
1954
1955         switch (ui32VerbLevel)
1956         {
1957                 case DEBUG_REQUEST_VERBOSITY_LOW :
1958                 {
1959                         IMG_UINT32              ui32DeviceIndex;
1960                         PVRSRV_DEV_POWER_STATE  ePowerState;
1961                         IMG_BOOL                bRGXPoweredON;
1962
1963                         ui32DeviceIndex = psDevInfo->psDeviceNode->sDevId.ui32DeviceIndex;
1964
1965                         eError = PVRSRVGetDevicePowerState(ui32DeviceIndex, &ePowerState);
1966                         if (eError != PVRSRV_OK)
1967                         {
1968                                 PVR_DPF((PVR_DBG_ERROR, "RGXDebugRequestProcess: Error retrieving RGX power state. No debug info dumped."));
1969                                 goto Exit;
1970                         }
1971
1972                         bRGXPoweredON = (ePowerState == PVRSRV_DEV_POWER_STATE_ON);
1973
1974                         PVR_DUMPDEBUG_LOG(("------[ RGX summary ]------"));
1975                         PVR_DUMPDEBUG_LOG(("RGX BVNC: %s", RGX_BVNC_KM));
1976                         PVR_DUMPDEBUG_LOG(("RGX Power State: %s", _RGXGetDebugDevPowerStateString(ePowerState)));
1977
1978                         _RGXDumpRGXDebugSummary(pfnDumpDebugPrintf, psDevInfo, bRGXPoweredON);
1979
1980                         if (bRGXPoweredON)
1981                         {
1982
1983                                 PVR_DUMPDEBUG_LOG(("------[ RGX registers ]------"));
1984                                 PVR_DUMPDEBUG_LOG(("RGX Register Base Address (Linear):   0x%p", psDevInfo->pvRegsBaseKM));
1985                                 PVR_DUMPDEBUG_LOG(("RGX Register Base Address (Physical): 0x%08lX", (unsigned long)psDevInfo->sRegsPhysBase.uiAddr));
1986
1987                                 /* Forcing bit 6 of MslvCtrl1 to 0 to avoid internal reg read going though the core */
1988                                 OSWriteHWReg32(psDevInfo->pvRegsBaseKM, RGX_CR_META_SP_MSLVCTRL1, 0x0);
1989
1990                                 eError = RGXRunScript(psDevInfo, psDevInfo->psScripts->asDbgCommands, RGX_MAX_INIT_COMMANDS, PDUMP_FLAGS_CONTINUOUS, pfnDumpDebugPrintf);
1991                                 if (eError != PVRSRV_OK)
1992                                 {
1993                                         PVR_DPF((PVR_DBG_WARNING,"RGXDebugRequestProcess: RGXRunScript failed (%d) - Retry", eError));
1994
1995                                         /* use thread1 for slave port accesses */
1996                                         OSWriteHWReg32(psDevInfo->pvRegsBaseKM, RGX_CR_META_SP_MSLVCTRL1, 0x1 << RGX_CR_META_SP_MSLVCTRL1_THREAD_SHIFT);
1997
1998                                         eError = RGXRunScript(psDevInfo, psDevInfo->psScripts->asDbgCommands, RGX_MAX_INIT_COMMANDS, PDUMP_FLAGS_CONTINUOUS, pfnDumpDebugPrintf);
1999                                         if (eError != PVRSRV_OK)
2000                                         {
2001                                                 PVR_DPF((PVR_DBG_ERROR,"RGXDebugRequestProcess: RGXRunScript retry failed (%d) - Dump Slave Port debug information", eError));
2002                                                 _RGXDumpMetaSPExtraDebugInfo(pfnDumpDebugPrintf, psDevInfo);
2003                                         }
2004
2005                                         /* use thread0 again */
2006                                         OSWriteHWReg32(psDevInfo->pvRegsBaseKM, RGX_CR_META_SP_MSLVCTRL1, 0x0 << RGX_CR_META_SP_MSLVCTRL1_THREAD_SHIFT);
2007                                 }
2008                         }
2009                         else
2010                         {
2011                                 PVR_DUMPDEBUG_LOG((" (!) RGX power is down. No registers dumped"));
2012                         }
2013
2014                         {
2015                                 RGXFWIF_DM      eKCCBType;
2016
2017                                 /*
2018                                         Dump out the kernel CCBs.
2019                                 */
2020                                 for (eKCCBType = 0; eKCCBType < RGXFWIF_DM_MAX; eKCCBType++)
2021                                 {
2022                                         RGXFWIF_CCB_CTL *psKCCBCtl = psDevInfo->apsKernelCCBCtl[eKCCBType];
2023
2024                                         if (psKCCBCtl != IMG_NULL)
2025                                         {
2026                                                 PVR_DUMPDEBUG_LOG(("RGX Kernel CCB %u WO:0x%X RO:0x%X",
2027                                                                   eKCCBType, psKCCBCtl->ui32WriteOffset, psKCCBCtl->ui32ReadOffset));
2028                                         }
2029                                 }
2030                         }
2031
2032                         /* Dump the KCCB commands executed */
2033                         {
2034                                 PVR_DUMPDEBUG_LOG(("RGX Kernel CCB commands executed = %d",
2035                                                   psDevInfo->psRGXFWIfTraceBuf->ui32KCCBCmdsExecuted));
2036                         }
2037
2038                         /* Dump the IRQ info */
2039                         {
2040                                 PVR_DUMPDEBUG_LOG(("RGX FW IRQ count = %d, last sampled in MISR = %d",
2041                                                   psDevInfo->psRGXFWIfTraceBuf->ui32InterruptCount,
2042                                                   g_ui32HostSampleIRQCount));
2043                         }
2044
2045                         /* Dump the FW config flags */
2046                         {
2047                                 RGXFWIF_INIT            *psRGXFWInit;
2048
2049                                 eError = DevmemAcquireCpuVirtAddr(psDevInfo->psRGXFWIfInitMemDesc,
2050                                                 (IMG_VOID **)&psRGXFWInit);
2051
2052                                 if (eError != PVRSRV_OK)
2053                                 {
2054                                         PVR_DPF((PVR_DBG_ERROR,"RGXDebugRequestProcess: Failed to acquire kernel fw if ctl (%u)",
2055                                                                 eError));
2056                                         goto Exit;
2057                                 }
2058
2059                                 PVR_DUMPDEBUG_LOG(("RGX FW config flags = 0x%X", psRGXFWInit->ui32ConfigFlags));
2060
2061                                 DevmemReleaseCpuVirtAddr(psDevInfo->psRGXFWIfInitMemDesc);
2062                         }
2063
2064                         break;
2065
2066                 }
2067                 case DEBUG_REQUEST_VERBOSITY_MEDIUM :
2068                 {
2069                         IMG_INT tid;
2070                         /* Dump FW trace information */
2071                         if (psDevInfo->psRGXFWIfTraceBuf != IMG_NULL)
2072                         {
2073                                 RGXFWIF_TRACEBUF *psRGXFWIfTraceBufCtl = psDevInfo->psRGXFWIfTraceBuf;
2074
2075                                 for ( tid = 0 ; tid < RGXFW_THREAD_NUM ; tid++)
2076                                 {
2077                                         IMG_UINT32      i;
2078                                         IMG_BOOL        bPrevLineWasZero = IMG_FALSE;
2079                                         IMG_BOOL        bLineIsAllZeros = IMG_FALSE;
2080                                         IMG_UINT32      ui32CountLines = 0;
2081                                         IMG_UINT32      *pui32TraceBuffer;
2082                                         IMG_CHAR        *pszLine;
2083
2084                                         pui32TraceBuffer = &psRGXFWIfTraceBufCtl->sTraceBuf[tid].aui32TraceBuffer[0];
2085
2086                                         /* each element in the line is 8 characters plus a space.  The '+1' is because of the final trailing '\0'. */
2087                                         pszLine = OSAllocMem(9*RGXFW_TRACE_BUFFER_LINESIZE+1);
2088                                         if (pszLine == IMG_NULL)
2089                                         {
2090                                                 PVR_DPF((PVR_DBG_ERROR,"RGXDebugRequestProcess: Out of mem allocating line string (size: %d)", 9*RGXFW_TRACE_BUFFER_LINESIZE));
2091                                                 goto Exit;
2092                                         }
2093
2094                                         /* Print the tracepointer */
2095                                         if (psRGXFWIfTraceBufCtl->ui32LogType & RGXFWIF_LOG_TYPE_GROUP_MASK)
2096                                         {
2097                                                 PVR_DUMPDEBUG_LOG(("Debug log type: %s ( " RGXFWIF_LOG_ENABLED_GROUPS_LIST_PFSPEC ")",
2098                                                                   ((psRGXFWIfTraceBufCtl->ui32LogType & RGXFWIF_LOG_TYPE_TRACE)?("trace"):("tbi")),
2099                                                                   RGXFWIF_LOG_ENABLED_GROUPS_LIST(psRGXFWIfTraceBufCtl->ui32LogType)
2100                                                                   ));
2101                                         }
2102                                         else
2103                                         {
2104                                                 PVR_DUMPDEBUG_LOG(("Debug log type: none"));
2105                                         }
2106
2107                                         PVR_DUMPDEBUG_LOG(("------[ RGX FW thread %d trace START ]------", tid));
2108                                         PVR_DUMPDEBUG_LOG(("FWT[traceptr]: %X", psRGXFWIfTraceBufCtl->sTraceBuf[tid].ui32TracePointer));
2109                                         PVR_DUMPDEBUG_LOG(("FWT[tracebufsize]: %X", RGXFW_TRACE_BUFFER_SIZE));
2110
2111                                         for (i = 0; i < RGXFW_TRACE_BUFFER_SIZE; i += RGXFW_TRACE_BUFFER_LINESIZE)
2112                                         {
2113                                                 IMG_UINT32 k = 0;
2114                                                 IMG_UINT32 ui32Line = 0x0;
2115                                                 IMG_UINT32 ui32LineOffset = i*sizeof(IMG_UINT32);
2116                                                 IMG_CHAR   *pszBuf = pszLine;
2117
2118                                                 for (k = 0; k < RGXFW_TRACE_BUFFER_LINESIZE; k++)
2119                                                 {
2120                                                         ui32Line |= pui32TraceBuffer[i + k];
2121
2122                                                         /* prepare the line to print it. The '+1' is because of the trailing '\0' added */
2123                                                         OSSNPrintf(pszBuf, 9 + 1, " %08x", pui32TraceBuffer[i + k]);
2124                                                         pszBuf += 9; /* write over the '\0' */
2125                                                 }
2126
2127                                                 bLineIsAllZeros = (ui32Line == 0x0);
2128
2129                                                 if (bLineIsAllZeros && bPrevLineWasZero)
2130                                                 {
2131                                                         ui32CountLines++;
2132                                                 }
2133                                                 else if (bLineIsAllZeros && !bPrevLineWasZero)
2134                                                 {
2135                                                         bPrevLineWasZero = IMG_TRUE;
2136                                                         ui32CountLines = 0;
2137                                                         PVR_DUMPDEBUG_LOG(("FWT[%08x]: 00000000 ... 00000000", ui32LineOffset));
2138                                                 }
2139                                                 else
2140                                                 {
2141                                                         if (bPrevLineWasZero)
2142                                                         {
2143                                                                 PVR_DUMPDEBUG_LOG(("FWT[%08x]: %d lines were all zero", ui32LineOffset, ui32CountLines));
2144                                                         }
2145                                                         else
2146                                                         {
2147
2148                                                                 PVR_DUMPDEBUG_LOG(("FWT[%08x]:%s", ui32LineOffset, pszLine));
2149                                                         }
2150                                                         bPrevLineWasZero = IMG_FALSE;
2151                                                 }
2152
2153                                         }
2154                                         if (bPrevLineWasZero)
2155                                         {
2156                                                 PVR_DUMPDEBUG_LOG(("FWT[END]: %d lines were all zero", ui32CountLines));
2157                                         }
2158
2159                                         PVR_DUMPDEBUG_LOG(("------[ RGX FW thread %d trace END ]------", tid));
2160
2161                                         OSFreeMem(pszLine);
2162                                 }
2163                         }
2164
2165                         {
2166                                 PVR_DUMPDEBUG_LOG(("------[ Stalled FWCtxs ]------"));
2167
2168                                 CheckForStalledTransferCtxt(psDevInfo, pfnDumpDebugPrintf);
2169                                 CheckForStalledRenderCtxt(psDevInfo, pfnDumpDebugPrintf);
2170 #if !defined(UNDER_WDDM)
2171                                 CheckForStalledComputeCtxt(psDevInfo, pfnDumpDebugPrintf);
2172 #endif
2173 #if defined(RGX_FEATURE_RAY_TRACING)
2174                                 CheckForStalledRayCtxt(psDevInfo, pfnDumpDebugPrintf);
2175 #endif
2176                         }
2177                         break;
2178                 }
2179                 case DEBUG_REQUEST_VERBOSITY_HIGH:
2180                 {
2181                         PVRSRV_ERROR            eError;
2182                         IMG_UINT32              ui32DeviceIndex;
2183                         PVRSRV_DEV_POWER_STATE  ePowerState;
2184                         IMG_BOOL                bRGXPoweredON;
2185
2186                         ui32DeviceIndex = psDevInfo->psDeviceNode->sDevId.ui32DeviceIndex;
2187
2188                         eError = PVRSRVGetDevicePowerState(ui32DeviceIndex, &ePowerState);
2189                         if (eError != PVRSRV_OK)
2190                         {
2191                                 PVR_DPF((PVR_DBG_ERROR, "RGXDebugRequestProcess: Error retrieving RGX power state. No debug info dumped."));
2192                                 return;
2193                         }
2194
2195                         bRGXPoweredON = (ePowerState == PVRSRV_DEV_POWER_STATE_ON);
2196
2197                         PVR_DUMPDEBUG_LOG(("------[ Debug bus ]------"));
2198
2199                         _RGXDumpRGXDebugSummary(pfnDumpDebugPrintf, psDevInfo, bRGXPoweredON);
2200
2201                         if (bRGXPoweredON)
2202                         {
2203                                 eError = RGXRunScript(psDevInfo, psDevInfo->psScripts->asDbgBusCommands, RGX_MAX_DBGBUS_COMMANDS, PDUMP_FLAGS_CONTINUOUS, pfnDumpDebugPrintf);
2204                                 if (eError != PVRSRV_OK)
2205                                 {
2206                                         PVR_DPF((PVR_DBG_WARNING,"RGXDebugRequestProcess: RGXRunScript failed (%s)", PVRSRVGetErrorStringKM(eError)));
2207                                 }
2208                                 break;
2209                         }
2210                 }
2211                 default:
2212                         break;
2213         }
2214
2215 Exit:
2216         PVRSRVPowerUnlock();
2217 }
2218
2219 /*
2220         RGXPanic
2221 */
2222 IMG_VOID RGXPanic(PVRSRV_RGXDEV_INFO    *psDevInfo)
2223 {
2224         PVR_LOG(("RGX panic"));
2225         PVRSRVDebugRequest(DEBUG_REQUEST_VERBOSITY_MAX, IMG_NULL);
2226         OSPanic();
2227 }
2228
2229 /*
2230         RGXQueryDMState
2231 */
2232 PVRSRV_ERROR RGXQueryDMState(PVRSRV_RGXDEV_INFO *psDevInfo, RGXFWIF_DM eDM, RGXFWIF_DM_STATE *peState, RGXFWIF_DEV_VIRTADDR *psCommonContextDevVAddr)
2233 {
2234         PVRSRV_ERROR    eError = PVRSRV_OK;
2235         RGXFWIF_TRACEBUF *psRGXFWIfTraceBufCtl = psDevInfo->psRGXFWIfTraceBuf;
2236
2237         if (eDM >= RGXFWIF_DM_MAX)
2238         {
2239                 eError = PVRSRV_ERROR_INVALID_PARAMS;
2240                 PVR_DPF((PVR_DBG_ERROR,"RGXQueryDMState: eDM parameter is out of range (%u)",eError));
2241                 return eError;
2242         }
2243
2244         if (peState == IMG_NULL)
2245         {
2246                 eError = PVRSRV_ERROR_INVALID_PARAMS;
2247                 PVR_DPF((PVR_DBG_ERROR,"RGXQueryDMState: peState is NULL (%u)",eError));
2248                 return eError;
2249         }
2250
2251         if (psCommonContextDevVAddr == IMG_NULL)
2252         {
2253                 eError = PVRSRV_ERROR_INVALID_PARAMS;
2254                 PVR_DPF((PVR_DBG_ERROR,"RGXQueryDMState: psCommonContextDevVAddr is NULL (%u)",eError));
2255                 return eError;
2256         }
2257
2258         if (eError != PVRSRV_OK)
2259         {
2260                 PVR_DPF((PVR_DBG_ERROR,"RGXQueryDMState: Failed (%d) to acquire address for trace buffer", eError));
2261                 return eError;
2262         }
2263
2264         if (psRGXFWIfTraceBufCtl->apsHwrDmFWCommonContext[eDM].ui32Addr)
2265         {
2266                 *peState = RGXFWIF_DM_STATE_LOCKEDUP;
2267         }
2268         else
2269         {
2270                 *peState = RGXFWIF_DM_STATE_NORMAL;
2271         }
2272
2273         *psCommonContextDevVAddr = psRGXFWIfTraceBufCtl->apsHwrDmFWCommonContext[eDM];
2274
2275         return eError;
2276 }
2277
2278
2279 /******************************************************************************
2280  End of file (rgxdebug.c)
2281 ******************************************************************************/