drivers/pvr/services4/srvkm/env/linux/pdump.c

   1 /**********************************************************************
   2  Copyright (c) Imagination Technologies Ltd.
   3
   4  Permission is hereby granted, free of charge, to any person obtaining a copy
   5  of this software and associated documentation files (the "Software"), to deal
   6  in the Software without restriction, including without limitation the rights
   7  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  copies of the Software, and to permit persons to whom the Software is
   9  furnished to do so, subject to the following conditions:
  10
  11  The above copyright notice and this permission notice shall be included in
  12  all copies or substantial portions of the Software.
  13
  14  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  THE SOFTWARE.
  21  ******************************************************************************/
  22
  23 #if defined (SUPPORT_SGX)
  24 #if defined (PDUMP)
  25
  26 #include <asm/atomic.h>
  27 #include <stdarg.h>
  28 #include "sgxdefs.h"
  29 #include "services_headers.h"
  30
  31 #include "pvrversion.h"
  32 #include "pvr_debug.h"
  33
  34 #include "dbgdrvif.h"
  35 #include "sgxmmu.h"
  36 #include "mm.h"
  37 #include "pdump_km.h"
  38
  39 #include <linux/tty.h>
  40
  41 static IMG_BOOL PDumpWriteString2               (IMG_CHAR * pszString, IMG_UINT32 ui32Flags);
  42 static IMG_BOOL PDumpWriteILock                 (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags);
  43 static IMG_VOID DbgSetFrame                             (PDBG_STREAM psStream, IMG_UINT32 ui32Frame);
  44 static IMG_UINT32 DbgGetFrame                   (PDBG_STREAM psStream);
  45 static IMG_VOID DbgSetMarker                    (PDBG_STREAM psStream, IMG_UINT32 ui32Marker);
  46 static IMG_UINT32 DbgWrite                              (PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags);
  47
  48 #define PDUMP_DATAMASTER_PIXEL          (1)
  49 #define PDUMP_DATAMASTER_EDM            (3)
  50
  51 #define MIN(a,b)       (a > b ? b : a)
  52
  53 #define MAX_FILE_SIZE   0x40000000
  54
  55 static atomic_t gsPDumpSuspended = ATOMIC_INIT(0);
  56
  57 static PDBGKM_SERVICE_TABLE gpfnDbgDrv = IMG_NULL;
  58
  59
  60
  61 IMG_CHAR *pszStreamName[PDUMP_NUM_STREAMS] = {  "ParamStream2",
  62                                                                                                 "ScriptStream2",
  63                                                                                                 "DriverInfoStream"};
  64 typedef struct PDBG_PDUMP_STATE_TAG
  65 {
  66         PDBG_STREAM psStream[PDUMP_NUM_STREAMS];
  67         IMG_UINT32 ui32ParamFileNum;
  68
  69         IMG_CHAR *pszMsg;
  70         IMG_CHAR *pszScript;
  71         IMG_CHAR *pszFile;
  72
  73 } PDBG_PDUMP_STATE;
  74
  75 static PDBG_PDUMP_STATE gsDBGPdumpState = {{IMG_NULL}, 0, IMG_NULL, IMG_NULL, IMG_NULL};
  76
  77 #define SZ_MSG_SIZE_MAX                 PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  78 #define SZ_SCRIPT_SIZE_MAX              PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  79 #define SZ_FILENAME_SIZE_MAX    PVRSRV_PDUMP_MAX_COMMENT_SIZE-1
  80
  81
  82
  83
  84 IMG_VOID DBGDrvGetServiceTable(IMG_VOID **fn_table);
  85
  86 static inline IMG_BOOL PDumpSuspended(IMG_VOID)
  87 {
  88         return atomic_read(&gsPDumpSuspended) != 0;
  89 }
  90
  91 PVRSRV_ERROR PDumpOSGetScriptString(IMG_HANDLE *phScript,
  92                                                                         IMG_UINT32 *pui32MaxLen)
  93 {
  94         *phScript = (IMG_HANDLE)gsDBGPdumpState.pszScript;
  95         *pui32MaxLen = SZ_SCRIPT_SIZE_MAX;
  96         if ((!*phScript) || PDumpSuspended())
  97         {
  98                 return PVRSRV_ERROR_GENERIC;
  99         }
 100         return PVRSRV_OK;
 101 }
 102
 103 PVRSRV_ERROR PDumpOSGetMessageString(IMG_HANDLE *phMsg,
 104                                                                          IMG_UINT32 *pui32MaxLen)
 105 {
 106         *phMsg = (IMG_HANDLE)gsDBGPdumpState.pszMsg;
 107         *pui32MaxLen = SZ_MSG_SIZE_MAX;
 108         if ((!*phMsg) || PDumpSuspended())
 109         {
 110                 return PVRSRV_ERROR_GENERIC;
 111         }
 112         return PVRSRV_OK;
 113 }
 114
 115 PVRSRV_ERROR PDumpOSGetFilenameString(IMG_CHAR **ppszFile,
 116                                                                          IMG_UINT32 *pui32MaxLen)
 117 {
 118         *ppszFile = gsDBGPdumpState.pszFile;
 119         *pui32MaxLen = SZ_FILENAME_SIZE_MAX;
 120         if ((!*ppszFile) || PDumpSuspended())
 121         {
 122                 return PVRSRV_ERROR_GENERIC;
 123         }
 124         return PVRSRV_OK;
 125 }
 126
 127 IMG_BOOL PDumpOSWriteString2(IMG_HANDLE hScript, IMG_UINT32 ui32Flags)
 128 {
 129         return PDumpWriteString2(hScript, ui32Flags);
 130 }
 131
 132 PVRSRV_ERROR PDumpOSBufprintf(IMG_HANDLE hBuf, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, ...)
 133 {
 134         IMG_CHAR* pszBuf = hBuf;
 135         IMG_UINT32 n;
 136         va_list vaArgs;
 137
 138         va_start(vaArgs, pszFormat);
 139
 140         n = vsnprintf(pszBuf, ui32ScriptSizeMax, pszFormat, vaArgs);
 141
 142         va_end(vaArgs);
 143
 144         if (n>=ui32ScriptSizeMax || n==-1)
 145         {
 146                 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
 147
 148                 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
 149         }
 150
 151         return PVRSRV_OK;
 152 }
 153
 154 PVRSRV_ERROR PDumpOSVSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR* pszFormat, PDUMP_va_list vaArgs)
 155 {
 156         IMG_UINT32 n;
 157
 158         n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
 159
 160         if (n>=ui32ScriptSizeMax || n==-1)
 161         {
 162                 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
 163
 164                 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
 165         }
 166
 167         return PVRSRV_OK;
 168 }
 169
 170 IMG_VOID PDumpOSDebugPrintf(IMG_CHAR* pszFormat, ...)
 171 {
 172
 173 }
 174
 175 PVRSRV_ERROR PDumpOSSprintf(IMG_CHAR *pszComment, IMG_UINT32 ui32ScriptSizeMax, IMG_CHAR *pszFormat, ...)
 176 {
 177         IMG_UINT32 n;
 178         va_list vaArgs;
 179
 180         va_start(vaArgs, pszFormat);
 181
 182         n = vsnprintf(pszComment, ui32ScriptSizeMax, pszFormat, vaArgs);
 183
 184         va_end(vaArgs);
 185
 186         if (n>=ui32ScriptSizeMax || n==-1)
 187         {
 188                 PVR_DPF((PVR_DBG_ERROR, "Buffer overflow detected, pdump output may be incomplete."));
 189
 190                 return PVRSRV_ERROR_PDUMP_BUF_OVERFLOW;
 191         }
 192
 193         return PVRSRV_OK;
 194 }
 195
 196 IMG_UINT32 PDumpOSBuflen(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
 197 {
 198         IMG_CHAR* pszBuf = hBuffer;
 199         IMG_UINT32 ui32Count = 0;
 200
 201         while ((pszBuf[ui32Count]!=0) && (ui32Count<ui32BufferSizeMax) )
 202         {
 203                 ui32Count++;
 204         }
 205         return(ui32Count);
 206 }
 207
 208 IMG_VOID PDumpOSVerifyLineEnding(IMG_HANDLE hBuffer, IMG_UINT32 ui32BufferSizeMax)
 209 {
 210         IMG_UINT32 ui32Count = 0;
 211         IMG_CHAR* pszBuf = hBuffer;
 212
 213
 214         ui32Count = PDumpOSBuflen(hBuffer, ui32BufferSizeMax);
 215
 216
 217         if ((ui32Count >= 1) && (pszBuf[ui32Count-1] != '\n') && (ui32Count<ui32BufferSizeMax))
 218         {
 219                 pszBuf[ui32Count] = '\n';
 220                 ui32Count++;
 221                 pszBuf[ui32Count] = '\0';
 222         }
 223         if ((ui32Count >= 2) && (pszBuf[ui32Count-2] != '\r') && (ui32Count<ui32BufferSizeMax))
 224         {
 225                 pszBuf[ui32Count-1] = '\r';
 226                 pszBuf[ui32Count] = '\n';
 227                 ui32Count++;
 228                 pszBuf[ui32Count] = '\0';
 229         }
 230 }
 231
 232 IMG_HANDLE PDumpOSGetStream(IMG_UINT32 ePDumpStream)
 233 {
 234         return (IMG_HANDLE)gsDBGPdumpState.psStream[ePDumpStream];
 235 }
 236
 237 IMG_UINT32 PDumpOSGetStreamOffset(IMG_UINT32 ePDumpStream)
 238 {
 239         PDBG_STREAM psStream = gsDBGPdumpState.psStream[ePDumpStream];
 240         return gpfnDbgDrv->pfnGetStreamOffset(psStream);
 241 }
 242
 243 IMG_UINT32 PDumpOSGetParamFileNum(IMG_VOID)
 244 {
 245         return gsDBGPdumpState.ui32ParamFileNum;
 246 }
 247
 248 IMG_BOOL PDumpOSWriteString(IMG_HANDLE hStream,
 249                 IMG_UINT8 *psui8Data,
 250                 IMG_UINT32 ui32Size,
 251                 IMG_UINT32 ui32Flags)
 252 {
 253         PDBG_STREAM psStream = (PDBG_STREAM)hStream;
 254         return PDumpWriteILock(psStream,
 255                                         psui8Data,
 256                                         ui32Size,
 257                                         ui32Flags);
 258 }
 259
 260 IMG_VOID PDumpOSCheckForSplitting(IMG_HANDLE hStream, IMG_UINT32 ui32Size, IMG_UINT32 ui32Flags)
 261 {
 262
 263         PVR_UNREFERENCED_PARAMETER(hStream);
 264         PVR_UNREFERENCED_PARAMETER(ui32Size);
 265         PVR_UNREFERENCED_PARAMETER(ui32Size);
 266 }
 267
 268 IMG_BOOL PDumpOSJTInitialised(IMG_VOID)
 269 {
 270         if(gpfnDbgDrv)
 271         {
 272                 return IMG_TRUE;
 273         }
 274         return IMG_FALSE;
 275 }
 276
 277 inline IMG_BOOL PDumpOSIsSuspended(IMG_VOID)
 278 {
 279         return atomic_read(&gsPDumpSuspended) != 0;
 280 }
 281
 282 IMG_VOID PDumpOSCPUVAddrToDevPAddr(PVRSRV_DEVICE_TYPE eDeviceType,
 283         IMG_HANDLE hOSMemHandle,
 284                 IMG_UINT32 ui32Offset,
 285                 IMG_UINT8 *pui8LinAddr,
 286                 IMG_UINT32 ui32PageSize,
 287                 IMG_DEV_PHYADDR *psDevPAddr)
 288 {
 289         if(hOSMemHandle)
 290         {
 291
 292                 IMG_CPU_PHYADDR sCpuPAddr;
 293
 294                 PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
 295
 296                 sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
 297                 PVR_ASSERT((sCpuPAddr.uiAddr & (ui32PageSize - 1)) == 0);
 298
 299
 300                 *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
 301         }
 302         else
 303         {
 304                 IMG_CPU_PHYADDR sCpuPAddr;
 305
 306                 PVR_UNREFERENCED_PARAMETER(ui32Offset);
 307
 308                 sCpuPAddr = OSMapLinToCPUPhys(pui8LinAddr);
 309                 *psDevPAddr = SysCpuPAddrToDevPAddr(eDeviceType, sCpuPAddr);
 310         }
 311 }
 312
 313 IMG_VOID PDumpOSCPUVAddrToPhysPages(IMG_HANDLE hOSMemHandle,
 314                 IMG_UINT32 ui32Offset,
 315                 IMG_PUINT8 pui8LinAddr,
 316                 IMG_UINT32 *pui32PageOffset)
 317 {
 318         if(hOSMemHandle)
 319         {
 320
 321                 IMG_CPU_PHYADDR     sCpuPAddr;
 322
 323                 PVR_UNREFERENCED_PARAMETER(pui8LinAddr);
 324
 325                 sCpuPAddr = OSMemHandleToCpuPAddr(hOSMemHandle, ui32Offset);
 326             *pui32PageOffset = sCpuPAddr.uiAddr & (HOST_PAGESIZE() -1);
 327         }
 328         else
 329         {
 330                 PVR_UNREFERENCED_PARAMETER(hOSMemHandle);
 331                 PVR_UNREFERENCED_PARAMETER(ui32Offset);
 332
 333                 *pui32PageOffset = (IMG_UINT32)pui8LinAddr & (HOST_PAGESIZE() - 1);
 334         }
 335 }
 336
 337
 338
 339 IMG_VOID PDumpInit(IMG_VOID)
 340 {
 341         IMG_UINT32 i;
 342
 343
 344         if (!gpfnDbgDrv)
 345         {
 346                 DBGDrvGetServiceTable((IMG_VOID **)&gpfnDbgDrv);
 347
 348
 349
 350
 351                 if (gpfnDbgDrv == IMG_NULL)
 352                 {
 353                         return;
 354                 }
 355
 356                 if(!gsDBGPdumpState.pszFile)
 357                 {
 358                         if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszFile, 0,
 359                                 "Filename string") != PVRSRV_OK)
 360                         {
 361                                 goto init_failed;
 362                         }
 363                 }
 364
 365                 if(!gsDBGPdumpState.pszMsg)
 366                 {
 367                         if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszMsg, 0,
 368                                 "Message string") != PVRSRV_OK)
 369                         {
 370                                 goto init_failed;
 371                         }
 372                 }
 373
 374                 if(!gsDBGPdumpState.pszScript)
 375                 {
 376                         if(OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID *)&gsDBGPdumpState.pszScript, 0,
 377                                 "Script string") != PVRSRV_OK)
 378                         {
 379                                 goto init_failed;
 380                         }
 381                 }
 382
 383                 for(i=0; i < PDUMP_NUM_STREAMS; i++)
 384                 {
 385                         gsDBGPdumpState.psStream[i] = gpfnDbgDrv->pfnCreateStream(pszStreamName[i],
 386                                                                                                                 DEBUG_CAPMODE_FRAMED,
 387                                                                                                                 DEBUG_OUTMODE_STREAMENABLE,
 388                                                                                                                 0,
 389                                                                                                                 10);
 390
 391                         gpfnDbgDrv->pfnSetCaptureMode(gsDBGPdumpState.psStream[i],DEBUG_CAPMODE_FRAMED,0xFFFFFFFF, 0xFFFFFFFF, 1);
 392                         gpfnDbgDrv->pfnSetFrame(gsDBGPdumpState.psStream[i],0);
 393                 }
 394
 395                 PDUMPCOMMENT("Driver Product Name: %s", VS_PRODUCT_NAME);
 396                 PDUMPCOMMENT("Driver Product Version: %s (%s)", PVRVERSION_STRING, PVRVERSION_FILE);
 397                 PDUMPCOMMENT("Start of Init Phase");
 398         }
 399
 400         return;
 401
 402 init_failed:
 403
 404         if(gsDBGPdumpState.pszFile)
 405         {
 406                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
 407                 gsDBGPdumpState.pszFile = IMG_NULL;
 408         }
 409
 410         if(gsDBGPdumpState.pszScript)
 411         {
 412                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
 413                 gsDBGPdumpState.pszScript = IMG_NULL;
 414         }
 415
 416         if(gsDBGPdumpState.pszMsg)
 417         {
 418                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
 419                 gsDBGPdumpState.pszMsg = IMG_NULL;
 420         }
 421
 422         gpfnDbgDrv = IMG_NULL;
 423 }
 424
 425
 426 IMG_VOID PDumpDeInit(IMG_VOID)
 427 {
 428         IMG_UINT32 i;
 429
 430         for(i=0; i < PDUMP_NUM_STREAMS; i++)
 431         {
 432                 gpfnDbgDrv->pfnDestroyStream(gsDBGPdumpState.psStream[i]);
 433         }
 434
 435         if(gsDBGPdumpState.pszFile)
 436         {
 437                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_FILENAME_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszFile, 0);
 438                 gsDBGPdumpState.pszFile = IMG_NULL;
 439         }
 440
 441         if(gsDBGPdumpState.pszScript)
 442         {
 443                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_SCRIPT_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszScript, 0);
 444                 gsDBGPdumpState.pszScript = IMG_NULL;
 445         }
 446
 447         if(gsDBGPdumpState.pszMsg)
 448         {
 449                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, SZ_MSG_SIZE_MAX, (IMG_PVOID) gsDBGPdumpState.pszMsg, 0);
 450                 gsDBGPdumpState.pszMsg = IMG_NULL;
 451         }
 452
 453         gpfnDbgDrv = IMG_NULL;
 454 }
 455
 456 PVRSRV_ERROR PDumpStartInitPhaseKM(IMG_VOID)
 457 {
 458         IMG_UINT32 i;
 459
 460         if (gpfnDbgDrv)
 461         {
 462                 PDUMPCOMMENT("Start Init Phase");
 463                 for(i=0; i < PDUMP_NUM_STREAMS; i++)
 464                 {
 465                         gpfnDbgDrv->pfnStartInitPhase(gsDBGPdumpState.psStream[i]);
 466                 }
 467         }
 468         return PVRSRV_OK;
 469 }
 470
 471 PVRSRV_ERROR PDumpStopInitPhaseKM(IMG_VOID)
 472 {
 473         IMG_UINT32 i;
 474
 475         if (gpfnDbgDrv)
 476         {
 477                 PDUMPCOMMENT("Stop Init Phase");
 478
 479                 for(i=0; i < PDUMP_NUM_STREAMS; i++)
 480                 {
 481                         gpfnDbgDrv->pfnStopInitPhase(gsDBGPdumpState.psStream[i]);
 482                 }
 483         }
 484         return PVRSRV_OK;
 485 }
 486
 487 IMG_BOOL PDumpIsLastCaptureFrameKM(IMG_VOID)
 488 {
 489         return gpfnDbgDrv->pfnIsLastCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
 490 }
 491
 492
 493 IMG_BOOL PDumpIsCaptureFrameKM(IMG_VOID)
 494 {
 495         if (PDumpSuspended())
 496         {
 497                 return IMG_FALSE;
 498         }
 499         return gpfnDbgDrv->pfnIsCaptureFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], IMG_FALSE);
 500 }
 501
 502 PVRSRV_ERROR PDumpSetFrameKM(IMG_UINT32 ui32Frame)
 503 {
 504         IMG_UINT32      ui32Stream;
 505
 506         for     (ui32Stream = 0; ui32Stream < PDUMP_NUM_STREAMS; ui32Stream++)
 507         {
 508                 if      (gsDBGPdumpState.psStream[ui32Stream])
 509                 {
 510                         DbgSetFrame(gsDBGPdumpState.psStream[ui32Stream], ui32Frame);
 511                 }
 512         }
 513
 514         return PVRSRV_OK;
 515 }
 516
 517 PVRSRV_ERROR PDumpGetFrameKM(IMG_PUINT32 pui32Frame)
 518 {
 519         *pui32Frame = DbgGetFrame(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2]);
 520
 521         return PVRSRV_OK;
 522 }
 523
 524
 525
 526 static IMG_BOOL PDumpWriteString2(IMG_CHAR * pszString, IMG_UINT32 ui32Flags)
 527 {
 528         return PDumpWriteILock(gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2], (IMG_UINT8 *) pszString, strlen(pszString), ui32Flags);
 529 }
 530
 531
 532 static IMG_BOOL PDumpWriteILock(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32Count, IMG_UINT32 ui32Flags)
 533 {
 534         IMG_UINT32 ui32Written = 0;
 535         IMG_UINT32 ui32Off = 0;
 536
 537         if ((psStream == IMG_NULL) || PDumpSuspended() || ((ui32Flags & PDUMP_FLAGS_NEVER) != 0))
 538         {
 539                 return IMG_TRUE;
 540         }
 541
 542
 543
 544
 545         if (psStream == gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2])
 546         {
 547                 IMG_UINT32 ui32ParamOutPos = gpfnDbgDrv->pfnGetStreamOffset(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2]);
 548
 549                 if (ui32ParamOutPos + ui32Count > MAX_FILE_SIZE)
 550                 {
 551                         if ((gsDBGPdumpState.psStream[PDUMP_STREAM_SCRIPT2] && PDumpWriteString2("\r\n-- Splitting pdump output file\r\n\r\n", ui32Flags)))
 552                         {
 553                                 DbgSetMarker(gsDBGPdumpState.psStream[PDUMP_STREAM_PARAM2], ui32ParamOutPos);
 554                                 gsDBGPdumpState.ui32ParamFileNum++;
 555                         }
 556                 }
 557         }
 558
 559
 560         while (((IMG_UINT32) ui32Count > 0) && (ui32Written != 0xFFFFFFFF))
 561         {
 562                 ui32Written = DbgWrite(psStream, &pui8Data[ui32Off], ui32Count, ui32Flags);
 563
 564
 565
 566
 567                 if (ui32Written == 0)
 568                 {
 569                         OSReleaseThreadQuanta();
 570                 }
 571
 572                 if (ui32Written != 0xFFFFFFFF)
 573                 {
 574                         ui32Off += ui32Written;
 575                         ui32Count -= ui32Written;
 576                 }
 577         }
 578
 579         if (ui32Written == 0xFFFFFFFF)
 580         {
 581                 return IMG_FALSE;
 582         }
 583
 584         return IMG_TRUE;
 585 }
 586
 587 static IMG_VOID DbgSetFrame(PDBG_STREAM psStream, IMG_UINT32 ui32Frame)
 588 {
 589         gpfnDbgDrv->pfnSetFrame(psStream, ui32Frame);
 590 }
 591
 592
 593 static IMG_UINT32 DbgGetFrame(PDBG_STREAM psStream)
 594 {
 595         return gpfnDbgDrv->pfnGetFrame(psStream);
 596 }
 597
 598 static IMG_VOID DbgSetMarker(PDBG_STREAM psStream, IMG_UINT32 ui32Marker)
 599 {
 600         gpfnDbgDrv->pfnSetMarker(psStream, ui32Marker);
 601 }
 602
 603 static IMG_UINT32 DbgWrite(PDBG_STREAM psStream, IMG_UINT8 *pui8Data, IMG_UINT32 ui32BCount, IMG_UINT32 ui32Flags)
 604 {
 605         IMG_UINT32      ui32BytesWritten;
 606
 607         if ((ui32Flags & PDUMP_FLAGS_CONTINUOUS) != 0)
 608         {
 609
 610
 611                 if (((psStream->ui32CapMode & DEBUG_CAPMODE_FRAMED) != 0) &&
 612                     (psStream->ui32Start == 0xFFFFFFFFUL) &&
 613                     (psStream->ui32End == 0xFFFFFFFFUL) &&
 614                      psStream->bInitPhaseComplete)
 615                 {
 616                         ui32BytesWritten = ui32BCount;
 617                 }
 618                 else
 619                 {
 620                         ui32BytesWritten = gpfnDbgDrv->pfnDBGDrivWrite2(psStream, pui8Data, ui32BCount, 1);
 621                 }
 622         }
 623         else
 624         {
 625                 if (ui32Flags & PDUMP_FLAGS_LASTFRAME)
 626                 {
 627                         IMG_UINT32      ui32DbgFlags;
 628
 629                         ui32DbgFlags = 0;
 630                         if (ui32Flags & PDUMP_FLAGS_RESETLFBUFFER)
 631                         {
 632                                 ui32DbgFlags |= WRITELF_FLAGS_RESETBUF;
 633                         }
 634
 635                         ui32BytesWritten = gpfnDbgDrv->pfnWriteLF(psStream, pui8Data, ui32BCount, 1, ui32DbgFlags);
 636                 }
 637                 else
 638                 {
 639                         ui32BytesWritten = gpfnDbgDrv->pfnWriteBINCM(psStream, pui8Data, ui32BCount, 1);
 640                 }
 641         }
 642
 643         return ui32BytesWritten;
 644 }
 645
 646
 647 IMG_VOID PDumpSuspendKM(IMG_VOID)
 648 {
 649         atomic_inc(&gsPDumpSuspended);
 650 }
 651
 652 IMG_VOID PDumpResumeKM(IMG_VOID)
 653 {
 654         atomic_dec(&gsPDumpSuspended);
 655 }
 656
 657 #endif
 658 #endif